Package gov.nasa.arc.mct.fastplot.view

Source Code of gov.nasa.arc.mct.fastplot.view.TestPlotViewRole

/*******************************************************************************
* Mission Control Technologies, Copyright (c) 2009-2012, United States Government
* as represented by the Administrator of the National Aeronautics and Space
* Administration. All rights reserved.
*
* The MCT platform is licensed under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0.
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*
* MCT includes source code licensed under additional open source licenses. See
* the MCT Open Source Licenses file included with this distribution or the About
* MCT Licenses dialog available at runtime from the MCT Help menu for additional
* information.
*******************************************************************************/
package gov.nasa.arc.mct.fastplot.view;

import gov.nasa.arc.mct.components.AbstractComponent;
import gov.nasa.arc.mct.components.ExtendedProperties;
import gov.nasa.arc.mct.components.FeedProvider;
import gov.nasa.arc.mct.components.FeedProvider.RenderingInfo;
import gov.nasa.arc.mct.fastplot.access.PolicyManagerAccess;
import gov.nasa.arc.mct.fastplot.bridge.PlotConstants;
import gov.nasa.arc.mct.fastplot.bridge.PlotConstants.AxisOrientationSetting;
import gov.nasa.arc.mct.fastplot.bridge.PlotConstants.NonTimeAxisSubsequentBoundsSetting;
import gov.nasa.arc.mct.fastplot.bridge.PlotConstants.PlotLineConnectionType;
import gov.nasa.arc.mct.fastplot.bridge.PlotConstants.TimeAxisSubsequentBoundsSetting;
import gov.nasa.arc.mct.fastplot.bridge.PlotConstants.XAxisMaximumLocationSetting;
import gov.nasa.arc.mct.fastplot.bridge.PlotConstants.YAxisMaximumLocationSetting;
import gov.nasa.arc.mct.fastplot.bridge.PlotView;
import gov.nasa.arc.mct.fastplot.bridge.PlotterPlot;
import gov.nasa.arc.mct.fastplot.bridge.ShellPlotPackageImplementation;
import gov.nasa.arc.mct.fastplot.settings.PlotConfiguration;
import gov.nasa.arc.mct.fastplot.settings.PlotSettings;
import gov.nasa.arc.mct.fastplot.utils.AbbreviatingPlotLabelingAlgorithm;
import gov.nasa.arc.mct.gui.NamingContext;
import gov.nasa.arc.mct.platform.spi.PersistenceProvider;
import gov.nasa.arc.mct.platform.spi.Platform;
import gov.nasa.arc.mct.platform.spi.PlatformAccess;
import gov.nasa.arc.mct.policy.ExecutionResult;
import gov.nasa.arc.mct.policy.PolicyContext;
import gov.nasa.arc.mct.roles.events.AddChildEvent;
import gov.nasa.arc.mct.roles.events.PropertyChangeEvent;
import gov.nasa.arc.mct.roles.events.RemoveChildEvent;
import gov.nasa.arc.mct.services.activity.TimeService;
import gov.nasa.arc.mct.services.component.PolicyManager;
import gov.nasa.arc.mct.services.component.ViewInfo;
import gov.nasa.arc.mct.services.component.ViewType;

import java.awt.Color;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.swing.JComponent;
import javax.swing.SwingUtilities;

import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.testng.Assert;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

public class TestPlotViewRole {
 
  @Mock
  private AbstractComponent parentComponent;

 
  @Mock
  private FeedProvider feed1;
 
  @Mock
  private FeedProvider feed2;
 
  @Mock
  private FeedProvider feed3;
 
  @Mock
  private TimeService timeService;
 
  @Mock
  private AbstractComponent feed1Component;
 
  @Mock
  private AbstractComponent feed2Component;

  @Mock
  private AbstractComponent feed3Component;
 
  @Mock
  private PolicyManager policyManager;
  @Mock private PersistenceProvider mockProvider;
  @Mock private Platform mockPlatform;
 
 
  private AbstractComponent mockComponent;
 
  PolicyManagerAccess access;
  ExecutionResult result;
  String valueFifty = "50.0";

  private AbbreviatingPlotLabelingAlgorithm plotLabelingAlgorithm = new AbbreviatingPlotLabelingAlgorithm();
 
  @BeforeMethod
  public void setup() {
    MockitoAnnotations.initMocks(this);
    Mockito.when(feed1Component.getCapability(FeedProvider.class)).thenReturn(feed1);
    Mockito.when(feed1Component.isLeaf()).thenReturn(true);
    Mockito.when(feed2Component.getCapability(FeedProvider.class)).thenReturn(feed2);
    Mockito.when(timeService.getCurrentTime()).thenReturn(System.currentTimeMillis());
    Mockito.when(feed1.getTimeService()).thenReturn(timeService);
    Mockito.when(feed2.getTimeService()).thenReturn(timeService);
   
      Mockito.when(parentComponent.getComponents()).thenReturn(
                 Collections.<AbstractComponent> emptyList());
   
    access = new PolicyManagerAccess();
    access.setPolicyManager(policyManager);
    PolicyContext context = new PolicyContext();
        result = new ExecutionResult(context, true, "");
        Mockito.when(policyManager.execute(Mockito.anyString(), Mockito.any(PolicyContext.class))).thenReturn(result)
        mockComponent = new DummyComponent();
        new PlatformAccess().setPlatform(mockPlatform);
    Mockito.when(mockPlatform.getPersistenceProvider()).thenReturn(mockProvider);
  }
 
  @AfterMethod
  public void teardown() {
    new PlatformAccess().setPlatform(null);
  }
   
  public static class TestersComponent extends AbstractComponent{
      public TestersComponent(String id) {
          setId(id);
      }
  }
 
 
  @Test
  public void testSettingPersistance() {     
        // Test SetupPlot
      final String anyTimeSystem = "anyTimeSystem";
          MockitoAnnotations.initMocks(this);
      TestersComponent component = new TestersComponent("x");
      PlotViewManifestation originalPlotMan = new PlotViewManifestation(component, new ViewInfo(PlotViewManifestation.class,"",ViewType.OBJECT));
     
      GregorianCalendar now = new GregorianCalendar();
      GregorianCalendar nowPlus = new GregorianCalendar();
      nowPlus.add(Calendar.MINUTE, 1);
           
      originalPlotMan.setupPlot(new PlotSettings(AxisOrientationSetting.X_AXIS_AS_TIME,
           anyTimeSystem,
                     TimeService.DEFAULT_TIME_FORMAT,
               XAxisMaximumLocationSetting.MAXIMUM_AT_RIGHT,
               YAxisMaximumLocationSetting.MAXIMUM_AT_TOP,
               TimeAxisSubsequentBoundsSetting.JUMP,
               NonTimeAxisSubsequentBoundsSetting.AUTO,
               NonTimeAxisSubsequentBoundsSetting.AUTO,
               nowPlus.getTimeInMillis(), now.getTimeInMillis(), 150, 100, 0.01, 0.20, 0.20, true, false,
            PlotConstants.DEFAULT_PLOT_LINE_DRAW,
           PlotLineConnectionType.STEP_X_THEN_Y));
     
      // for coverage.
      originalPlotMan.updateMonitoredGUI();
      originalPlotMan.updateMonitoredGUI(new AddChildEvent(nowPlus, feed1Component));
      originalPlotMan.updateMonitoredGUI(new RemoveChildEvent(nowPlus, feed1Component));
     
      PlotView thePlotView = originalPlotMan.getPlot();     
      PlotConfiguration settings = new PlotPersistenceHandler(originalPlotMan).loadPlotSettingsFromPersistance();
      PlotView secondPlotView =  PlotViewFactory.createPlotFromSettings(settings, 1, plotLabelingAlgorithm);
     
      // Should be different plots.
      Assert.assertNotSame(thePlotView, secondPlotView);
     
      originalPlotMan.setupPlot(new PlotSettings(AxisOrientationSetting.X_AXIS_AS_TIME,
           anyTimeSystem,
                     TimeService.DEFAULT_TIME_FORMAT,
               XAxisMaximumLocationSetting.MAXIMUM_AT_RIGHT,
               YAxisMaximumLocationSetting.MAXIMUM_AT_TOP,
               TimeAxisSubsequentBoundsSetting.SCRUNCH,
               NonTimeAxisSubsequentBoundsSetting.AUTO,
               NonTimeAxisSubsequentBoundsSetting.AUTO,
               nowPlus.getTimeInMillis(), now.getTimeInMillis(), 150, 100, 0.01, 0.20, 0.20, true, false,
           PlotConstants.DEFAULT_PLOT_LINE_DRAW,
           PlotLineConnectionType.STEP_X_THEN_Y));
     
      originalPlotMan.updateMonitoredGUI();
     
      thePlotView = originalPlotMan.getPlot();     
      settings = new PlotPersistenceHandler(originalPlotMan).loadPlotSettingsFromPersistance();;
      secondPlotView = PlotViewFactory.createPlotFromSettings(settings, 1, plotLabelingAlgorithm);
       
      // Should be different plots.
      Assert.assertNotSame(thePlotView, secondPlotView);
     
     
  }
 
  @Test (dataProvider="ingoresPredictiveTimeServiceTestCases")
  public void testIgnoresPredictiveTimeService(boolean p1, boolean p2, boolean p3, final int t) {
        MockitoAnnotations.initMocks(this);

    Mockito.when(feed1Component.getCapability(FeedProvider.class)).thenReturn(feed1);
    Mockito.when(feed2Component.getCapability(FeedProvider.class)).thenReturn(feed2);
    Mockito.when(feed3Component.getCapability(FeedProvider.class)).thenReturn(feed3);
    Mockito.when(feed1Component.isLeaf()).thenReturn(true);
    Mockito.when(feed2Component.isLeaf()).thenReturn(true);
    Mockito.when(feed3Component.isLeaf()).thenReturn(true);

    Mockito.when(feed1.getTimeService()).thenReturn(makeStaticTimeService(1));
    Mockito.when(feed2.getTimeService()).thenReturn(makeStaticTimeService(2));
    Mockito.when(feed3.getTimeService()).thenReturn(makeStaticTimeService(3));
    Mockito.when(feed1.getSubscriptionId()).thenReturn("feed1");
    Mockito.when(feed2.getSubscriptionId()).thenReturn("feed2");
    Mockito.when(feed3.getSubscriptionId()).thenReturn("feed3");

        Mockito.when(feed1.isPrediction()).thenReturn(p1);
        Mockito.when(feed2.isPrediction()).thenReturn(p2);
        Mockito.when(feed3.isPrediction()).thenReturn(p3);
       
        SwingUtilities.invokeLater(new Runnable() {
          public void run() {

            TestersComponent component = new TestersComponent("x") {
              @Override
              public synchronized List<AbstractComponent> getComponents() { 
                return Arrays.asList(feed1Component, feed2Component, feed3Component);
              }
            };

            PlotViewManifestation plot;

            plot = new PlotViewManifestation(component, new ViewInfo(PlotViewManifestation.class,"",ViewType.OBJECT));
            Assert.assertEquals(plot.getCurrentMCTTime(), t); // First non-predictive;
          }
        });

  }
 
  @DataProvider
  public Object[][] ingoresPredictiveTimeServiceTestCases() {
    return new Object[][]{
        {true,true,true,1},
        {true,false,false,2},
        {false,false,false,1}       
    };
  }
 
  private TimeService makeStaticTimeService(final long time) {
    return new TimeService() {
      @Override
      public long getCurrentTime() {
        return time;
      }
    };
  }
 
  @SuppressWarnings({ "unchecked", "serial" })
  @Test
  public void testUpdateFromDataFeed() throws IllegalArgumentException, SecurityException, IllegalAccessException, NoSuchFieldException {

    final ExtendedProperties viewProps = new ExtendedProperties();
    PlotViewManifestation panel = new PlotViewManifestation(mockComponent,new ViewInfo(PlotViewManifestation.class,"", ViewType.OBJECT)) {
      @Override
      public ExtendedProperties getViewProperties() {
        return viewProps;
      }
    };

    panel.setPlot(new PlotView.Builder(ShellPlotPackageImplementation.class).build());
    ShellPlotPackageImplementation testPackage = (ShellPlotPackageImplementation) panel.getPlot().returnPlottingPackage();

    panel.getPlot().addDataSet("PUI1");
    panel.getPlot().addDataSet("PUI2");

    // Make feed Data
    Map<String, List<Map<String, String>>> theData = new Hashtable<String, List<Map<String, String>>>();

    List<Map<String, String>> dataSetA = new ArrayList<Map<String, String>>();
    List<Map<String, String>> dataSetB = new ArrayList<Map<String, String>>();

    // data set A two points
    Map<String, String> dataAPoint1 = new Hashtable<String, String>();
    dataAPoint1.put(FeedProvider.NORMALIZED_TIME_KEY, "1");
    dataAPoint1.put(FeedProvider.NORMALIZED_VALUE_KEY, valueFifty);
    dataAPoint1.put(FeedProvider.NORMALIZED_IS_VALID_KEY, "TRUE");
    dataAPoint1.put(FeedProvider.NORMALIZED_TELEMETRY_STATUS_CLASS_KEY, "1");
    RenderingInfo ri1 = new RenderingInfo(valueFifty, Color.BLACK, "X", Color.BLACK, true);
    Mockito.when(feed1.getRenderingInfo(Mockito.anyMap())).thenReturn(ri1);

    Map<String, String> dataAPoint2 = new Hashtable<String, String>();
    dataAPoint2.put(FeedProvider.NORMALIZED_TIME_KEY, "1");
    dataAPoint2.put(FeedProvider.NORMALIZED_VALUE_KEY, "86.2");
    dataAPoint2.put(FeedProvider.NORMALIZED_IS_VALID_KEY, "TRUE");
    dataAPoint2.put(FeedProvider.NORMALIZED_TELEMETRY_STATUS_CLASS_KEY, "1");

    dataSetA.add(dataAPoint1);
    dataSetA.add(dataAPoint2);

    theData.put("PUI1", dataSetA);

    // data set B two points
    Map<String, String> dataBPoint1 = new Hashtable<String, String>();
    dataBPoint1.put(FeedProvider.NORMALIZED_TIME_KEY, "1");
    dataBPoint1.put(FeedProvider.NORMALIZED_VALUE_KEY, "25.0");
    dataBPoint1.put(FeedProvider.NORMALIZED_IS_VALID_KEY, "TRUE");
    dataBPoint1.put(FeedProvider.NORMALIZED_TELEMETRY_STATUS_CLASS_KEY, "1");
    RenderingInfo ri2 = new RenderingInfo("25.0", Color.BLACK, "X", Color.BLACK, true);
    Mockito.when(feed2.getRenderingInfo(Mockito.anyMap())).thenReturn(ri2);
   
    Map<String, String> dataBPoint2 = new Hashtable<String, String>();
    dataBPoint2.put(FeedProvider.NORMALIZED_TIME_KEY, "1");
    dataBPoint2.put(FeedProvider.NORMALIZED_VALUE_KEY, "110.9");
    dataBPoint2.put(FeedProvider.NORMALIZED_IS_VALID_KEY, "TRUE");
    dataBPoint2.put(FeedProvider.NORMALIZED_TELEMETRY_STATUS_CLASS_KEY, "1");

    dataSetB.add(dataBPoint1);
    dataSetB.add(dataBPoint2);

    theData.put("PUI2", dataSetB);

    Mockito.when(feed1.getSubscriptionId()).thenReturn("PUI1");
    Mockito.when(feed2.getSubscriptionId()).thenReturn("PUI2");

    Field pda = PlotViewManifestation.class.getDeclaredField("plotDataAssigner");
    pda.setAccessible(true);
    PlotDataAssigner plotDataAssigner = (PlotDataAssigner) pda.get(panel);
    plotDataAssigner.getVisibleFeedProviders().add(feed1);
    plotDataAssigner.getVisibleFeedProviders().add(feed2);


    Assert.assertEquals(panel.getMaxFeedValue(), 0.0);
    Assert.assertEquals(panel.getMinFeedValue(), 0.0);
    // Push feed to plot.
    panel.updateFromFeed(theData);

    // Check data made it to the plot
    Map<String, ArrayList<Double>> plotDataSet =  testPackage.getDataSet();

    Assert.assertNotNull(plotDataSet);
    Assert.assertEquals(plotDataSet.size(), 2);
    Assert.assertTrue(plotDataSet.containsKey("pui2"));
    Assert.assertTrue(plotDataSet.containsKey("pui1"));
    ArrayList<Double> dataADataFromPlot = plotDataSet.get("pui1");
    ArrayList<Double> dataBDataFromPlot = plotDataSet.get("pui2");

   
    Assert.assertEquals(dataADataFromPlot.get(0), 50.0);


    Assert.assertEquals(dataBDataFromPlot.get(0), 25.0);

    panel.updateMonitoredGUI();

    GregorianCalendar now = new GregorianCalendar();
    Long mctTime = panel.getCurrentMCTTime();

    // Allow MCT time to be within a second of current time. This allows
    // time for the method call.
    Assert.assertTrue( mctTime <= now.getTimeInMillis() + 1000);

  }
   
  @Test
  public void testSetupChart() {
    TestersComponent component = new TestersComponent("x");
    PlotViewManifestation panel = new PlotViewManifestation(component, new ViewInfo(PlotViewManifestation.class,"",ViewType.OBJECT));
    PlotView originalPlot = new PlotView.Builder(ShellPlotPackageImplementation.class).build();
   
    panel.setPlot(originalPlot);
   
    GregorianCalendar minTime = new GregorianCalendar();
    GregorianCalendar maxTime = new GregorianCalendar();
    maxTime.setTimeInMillis(System.currentTimeMillis()+1);
    panel.setupPlot(new PlotSettings(AxisOrientationSetting.X_AXIS_AS_TIME,
             PlotConstants.DEFAULT_TIME_SYSTEM,
             PlotConstants.DEFAULT_TIME_FORMAT,
                 XAxisMaximumLocationSetting.MAXIMUM_AT_RIGHT,
                 YAxisMaximumLocationSetting.MAXIMUM_AT_TOP,
                 TimeAxisSubsequentBoundsSetting.JUMP,
                 NonTimeAxisSubsequentBoundsSetting.AUTO,
                 NonTimeAxisSubsequentBoundsSetting.AUTO,
                 maxTime.getTimeInMillis(), minTime.getTimeInMillis(), 0, 100, 0.05, 0.20, 0.20, true, false,
             PlotConstants.DEFAULT_PLOT_LINE_DRAW,
               PlotLineConnectionType.STEP_X_THEN_Y));
  }
   
  @Test
  public void testUpdateFromDataFeedNoData() {
    PlotViewManifestation panel = new PlotViewManifestation(mockComponent, new ViewInfo(PlotViewManifestation.class,"",ViewType.OBJECT));
    panel.setPlot(new PlotView.Builder(ShellPlotPackageImplementation.class).build());
   
    // Robust to no data.
    panel.updateFromFeed(null)
  }
 
  @SuppressWarnings("unchecked")
  @Test
  public void testRobustToNoDataForAFeed() throws IllegalArgumentException, SecurityException, IllegalAccessException, NoSuchFieldException {
    PlotViewManifestation panel = new PlotViewManifestation(mockComponent, new ViewInfo(PlotViewManifestation.class,"",ViewType.OBJECT));
    panel.setPlot(new PlotView.Builder(ShellPlotPackageImplementation.class).build());
   
    panel.getPlot().addDataSet("PUI1");
   
    // Robust to no data for feed.
    List<Map<String, String>> dataSetA = new ArrayList<Map<String, String>>();
    List<Map<String, String>> dataSetB = new ArrayList<Map<String, String>>();
   
    // data set A two points
    Map<String, String> dataAPoint1 = new Hashtable<String, String>();
    dataAPoint1.put(FeedProvider.NORMALIZED_TIME_KEY, "1");
    dataAPoint1.put(FeedProvider.NORMALIZED_VALUE_KEY, valueFifty);
    dataAPoint1.put(FeedProvider.NORMALIZED_IS_VALID_KEY, "TRUE")
    dataAPoint1.put(FeedProvider.NORMALIZED_TELEMETRY_STATUS_CLASS_KEY, "1");
      RenderingInfo ri1 = new RenderingInfo(valueFifty, Color.BLACK, "X", Color.BLACK, true);
        Mockito.when(feed1.getRenderingInfo(Mockito.anyMap())).thenReturn(ri1);

    Map<String, String> dataAPoint2 = new Hashtable<String, String>();
    dataAPoint2.put(FeedProvider.NORMALIZED_TIME_KEY, "1");
    dataAPoint2.put(FeedProvider.NORMALIZED_VALUE_KEY, "86.2");
    dataAPoint2.put(FeedProvider.NORMALIZED_IS_VALID_KEY, "TRUE");
    dataAPoint2.put(FeedProvider.NORMALIZED_TELEMETRY_STATUS_CLASS_KEY, "1");


    Map<String, String> dataAPoint3 = new Hashtable<String, String>();
    dataAPoint3.put(FeedProvider.NORMALIZED_TIME_KEY, "1");
    dataAPoint3.put(FeedProvider.NORMALIZED_VALUE_KEY, "");
    dataAPoint3.put(FeedProvider.NORMALIZED_IS_VALID_KEY, "TRUE");
    dataAPoint3.put(FeedProvider.NORMALIZED_TELEMETRY_STATUS_CLASS_KEY, "1");

    Map<String, String> dataAPoint4 = new Hashtable<String, String>();
    dataAPoint4.put(FeedProvider.NORMALIZED_TIME_KEY, "1");
    dataAPoint4.put(FeedProvider.NORMALIZED_VALUE_KEY, "86.2");
    dataAPoint4.put(FeedProvider.NORMALIZED_IS_VALID_KEY, "");
    dataAPoint4.put(FeedProvider.NORMALIZED_TELEMETRY_STATUS_CLASS_KEY, "1");

    Map<String, String> dataAPoint5 = new Hashtable<String, String>();
    dataAPoint5.put(FeedProvider.NORMALIZED_TIME_KEY, "");
    dataAPoint5.put(FeedProvider.NORMALIZED_VALUE_KEY, "86.2");
    dataAPoint5.put(FeedProvider.NORMALIZED_IS_VALID_KEY, "true");
    dataAPoint5.put(FeedProvider.NORMALIZED_TELEMETRY_STATUS_CLASS_KEY, "1");

    dataSetA.add(dataAPoint1);
    dataSetA.add(dataAPoint2);
    dataSetA.add(dataAPoint3);
    dataSetA.add(dataAPoint4);

    // Make feed Data
     Map<String, List<Map<String, String>>> theData = new Hashtable<String, List<Map<String, String>>>();
    theData.put("PUI1", dataSetA);
    theData.put("PUI2", dataSetB);

    Mockito.when(feed1.getSubscriptionId()).thenReturn("PUI1");
    Mockito.when(feed2.getSubscriptionId()).thenReturn("PUI2");

    Field pda = panel.getClass().getDeclaredField("plotDataAssigner");
    pda.setAccessible(true);
    PlotDataAssigner plotDataAssigner = (PlotDataAssigner) pda.get(panel);
    plotDataAssigner.getVisibleFeedProviders().add(feed1);
    plotDataAssigner.getVisibleFeedProviders().add(feed2);

    // Push feed to plot.
    panel.updateFromFeed(theData);

    // Check data made it to the plot
    ShellPlotPackageImplementation testPackage = (ShellPlotPackageImplementation) panel.getPlot().returnPlottingPackage();
    Map<String, ArrayList<Double>> plotDataSet = testPackage.getDataSet();

    Assert.assertEquals(plotDataSet.size(), 1);
    Assert.assertTrue(plotDataSet.containsKey("pui1"));
    Assert.assertFalse(plotDataSet.containsKey("pui2"));
    ArrayList<Double> dataADataFromPlot = plotDataSet.get("pui1");

   
    Assert.assertEquals(dataADataFromPlot.get(0), 50.0);
  }
 
 
  @Test (enabled = false)
  public void testUpdateDataAndThatUpdateFromFeedCachesWhileLockedOut() {
    PlotViewManifestation panel = new PlotViewManifestation(parentComponent,new ViewInfo(PlotViewManifestation.class,"",ViewType.CENTER));
    panel.setPlot(new PlotView.Builder(ShellPlotPackageImplementation.class).build());
   
    panel.getPlot().addDataSet("PUI1");
     
    List<Map<String, String>> dataSetAUpdateFromFeed = new ArrayList<Map<String, String>>();
    List<Map<String, String>> dataSetBUpdateData = new ArrayList<Map<String, String>>();
   
    // data set A two points
    Map<String, String> dataAPoint1 = new Hashtable<String, String>();
    dataAPoint1.put(FeedProvider.NORMALIZED_TIME_KEY, "2");
    dataAPoint1.put(FeedProvider.NORMALIZED_VALUE_KEY, valueFifty);
    dataAPoint1.put(FeedProvider.NORMALIZED_IS_VALID_KEY, "TRUE")
    dataAPoint1.put(FeedProvider.NORMALIZED_TELEMETRY_STATUS_CLASS_KEY, "1");
   
    Map<String, String> dataAPoint2 = new Hashtable<String, String>();
    dataAPoint2.put(FeedProvider.NORMALIZED_TIME_KEY, "3");
    dataAPoint2.put(FeedProvider.NORMALIZED_VALUE_KEY, "86.2");
    dataAPoint2.put(FeedProvider.NORMALIZED_IS_VALID_KEY, "TRUE");
    dataAPoint2.put(FeedProvider.NORMALIZED_TELEMETRY_STATUS_CLASS_KEY, "1");
   
    dataSetAUpdateFromFeed.add(dataAPoint1);
    dataSetAUpdateFromFeed.add(dataAPoint2);
   
    // data set B two points
    Map<String, String> dataBPoint1 = new Hashtable<String, String>();
    dataBPoint1.put(FeedProvider.NORMALIZED_TIME_KEY, "0");
    dataBPoint1.put(FeedProvider.NORMALIZED_VALUE_KEY, "25.0");
    dataBPoint1.put(FeedProvider.NORMALIZED_IS_VALID_KEY, "TRUE");
    dataBPoint1.put(FeedProvider.NORMALIZED_TELEMETRY_STATUS_CLASS_KEY, "1");
    Map<String, String> dataBPoint2 = new Hashtable<String, String>();
    dataBPoint2.put(FeedProvider.NORMALIZED_TIME_KEY, "1");
    dataBPoint2.put(FeedProvider.NORMALIZED_VALUE_KEY, "110.9");
    dataBPoint2.put(FeedProvider.NORMALIZED_IS_VALID_KEY, "TRUE");
    dataBPoint2.put(FeedProvider.NORMALIZED_TELEMETRY_STATUS_CLASS_KEY, "1");
   
    dataSetBUpdateData.add(dataBPoint1);
    dataSetBUpdateData.add(dataBPoint2);
   
    Map<String, List<Map<String, String>>> updateFromFeedData = new Hashtable<String, List<Map<String, String>>>();
    updateFromFeedData.put("PUI1", dataSetAUpdateFromFeed);
   
    Map<String, List<Map<String, String>>> updateData = new Hashtable<String, List<Map<String, String>>>();
    updateData.put("PUI1", dataSetBUpdateData);
   
    Mockito.when(feed1.getSubscriptionId()).thenReturn("PUI1");
   
       
  }

 
  @SuppressWarnings("serial")
  @Test
  public void testSynchronizeTime() {
    final ExtendedProperties viewProps = new ExtendedProperties();
    PlotViewManifestation panel = new PlotViewManifestation(mockComponent,new ViewInfo(PlotViewManifestation.class,"",ViewType.OBJECT)) {
      @Override
      public ExtendedProperties getViewProperties() {
        return viewProps;
      }
    };
    PlotView thePlot = new PlotView.Builder(PlotterPlot.class).build();
   
    AbbreviatingPlotLabelingAlgorithm plotLabelingAlgorithm = new AbbreviatingPlotLabelingAlgorithm();
    final String baseDisplayName = "DSCU PUI1";
    plotLabelingAlgorithm.setCanvasPanelTitle("PUI123");
    plotLabelingAlgorithm.setPanelOrWindowTitle("DSCU");
   
    panel.setPlot(thePlot);
    thePlot.setManifestation(panel);
    Assert.assertEquals(panel.getPlot(), thePlot);
   
    panel.getPlot().addDataSet(baseDisplayName);
   
    List<Map<String, String>> dataSetAUpdateFromFeed = new ArrayList<Map<String, String>>();
   
    // data set A two points
    Map<String, String> dataAPoint1 = new Hashtable<String, String>();
    dataAPoint1.put(FeedProvider.NORMALIZED_TIME_KEY, "2");
    dataAPoint1.put(FeedProvider.NORMALIZED_VALUE_KEY, valueFifty);
    dataAPoint1.put(FeedProvider.NORMALIZED_IS_VALID_KEY, "TRUE")
    dataAPoint1.put(FeedProvider.NORMALIZED_TELEMETRY_STATUS_CLASS_KEY, "1");
   
    Map<String, String> dataAPoint2 = new Hashtable<String, String>();
    dataAPoint2.put(FeedProvider.NORMALIZED_TIME_KEY, "3");
    dataAPoint2.put(FeedProvider.NORMALIZED_VALUE_KEY, "86.2");
    dataAPoint2.put(FeedProvider.NORMALIZED_IS_VALID_KEY, "TRUE");
    dataAPoint2.put(FeedProvider.NORMALIZED_TELEMETRY_STATUS_CLASS_KEY, "1");
   
    dataSetAUpdateFromFeed.add(dataAPoint1);
    dataSetAUpdateFromFeed.add(dataAPoint2);
   
   
    Map<String, List<Map<String, String>>> synchronizeTime = new Hashtable<String, List<Map<String, String>>>();
    synchronizeTime.put(baseDisplayName, dataSetAUpdateFromFeed);
   
   
    Mockito.when(feed1.getSubscriptionId()).thenReturn(baseDisplayName);

    panel.synchronizeTime(synchronizeTime, 0);
   
  }

  @Test
  public void testRobustToMissingData() {
    PlotViewManifestation panel = new PlotViewManifestation(mockComponent, new ViewInfo(PlotViewManifestation.class,"",ViewType.OBJECT));
    panel.setPlot(new PlotView.Builder(ShellPlotPackageImplementation.class).build());



    // Robust to no data for feed.
    List<Map<String, String>> dataSetA = new ArrayList<Map<String, String>>();

    // data set A two points
    Map<String, String> dataAPoint1 = new Hashtable<String, String>();
    // no time key
    dataAPoint1.put(FeedProvider.NORMALIZED_VALUE_KEY, valueFifty);
    Map<String, String> dataAPoint2 = new Hashtable<String, String>();
    dataAPoint2.put(FeedProvider.NORMALIZED_TIME_KEY, "1");
    // no value key.
    dataSetA.add(dataAPoint1);
    dataSetA.add(dataAPoint2);

    // Make feed Data
    Map<String, List<Map<String, String>>> theData = new Hashtable<String, List<Map<String, String>>>();
    theData.put("PUI1", dataSetA);

    Set<String> feedIDS = new HashSet<String>();
    feedIDS.add("PUI1");


    // Push feed to plot.
    panel.updateFromFeed(theData);

    ShellPlotPackageImplementation testPackage = (ShellPlotPackageImplementation) panel.getPlot().returnPlottingPackage();

    // Check data made it to the plot
    Map<String, ArrayList<Double>> plotDataSet = testPackage.getDataSet();

    Assert.assertEquals(plotDataSet.size(), 0);
  }
 
 
  /* Test equals and hashcode methods *.
   *
   * equals and hashCode must depend on the same set of "significant" fields.
   * You must use the same set of fields in both of these methods.
   * You are not required to use all fields.
   * For example, a calculated field that depends on others should very likely be
   * omitted from equals and hashCode.
   */
 
  @Test
  public void testEqualsAndHashCode() {
   
    // if two objects are equal, then their hashCode values must be equal as well
    PlotViewManifestation panelA = new PlotViewManifestation(mockComponent, new ViewInfo(PlotViewManifestation.class,"",ViewType.OBJECT));
    PlotViewManifestation panelPlotEqual = new PlotViewManifestation(mockComponent, new ViewInfo(PlotViewManifestation.class,"",ViewType.OBJECT));
    PlotViewManifestation panelNotEqualA = new PlotViewManifestation(mockComponent, new ViewInfo(PlotViewManifestation.class,"",ViewType.OBJECT));
   
    PlotView panelAsPlot = new PlotView.Builder(ShellPlotPackageImplementation.class).build();
    PlotView notPanelAsPlot = new PlotView.Builder(ShellPlotPackageImplementation.class).build();
   
    panelA.setPlot(panelAsPlot);
    panelPlotEqual.setPlot(panelAsPlot);
    panelNotEqualA.setPlot(notPanelAsPlot);
   
    // Two different manifestations.
    Assert.assertFalse(panelA.equals(panelPlotEqual));
 
    Assert.assertNotSame(panelA.hashCode(), panelPlotEqual.hashCode());
   
    // Check that do not equal a  general object
    Assert.assertFalse(panelA.equals(new Object()));
   
    // Equals one's self
    Assert.assertTrue(panelA.equals(panelA));
   
  }
 
  private Map<String,List<Map<String, String>>> generateDataSet(long...times) {
    List<Map<String,String>> dataSets = new ArrayList<Map<String,String>>();
    for (Long time : times) {
      Map<String,String> dataSet = new HashMap<String, String>();
      dataSets.add(dataSet);
      dataSet.put(FeedProvider.NORMALIZED_TIME_KEY, time.toString());
      dataSet.put(FeedProvider.NORMALIZED_VALUE_KEY, time.toString());
    }
   
    Map<String, List<Map<String,String>>> map = new HashMap<String, List<Map<String,String>>>();
    map.put("feedId", dataSets);
    return map;
  }
 
  @DataProvider(name="expandDataTest")
  public Object[][] createExpandDataTest() {
    return new Object[][] {
      new Object[] {generateDataSet(1L), 1L, 100L,new Long[] {1L}},
      new Object[] {generateDataSet(1L), 1L, 1001L, new Long[] {1L, 1001L}},
      new Object[] {generateDataSet(1L, 999L), 1L, 1001L, new Long[] {1L, 999L}},
      new Object[] {generateDataSet(1L), 1L, 3000L, new Long[] {1L, 1001L, 2001L}},
    };
  }
 
  @Test(dataProvider="expandDataTest")
  public void testExpandData(Map<String, List<Map<String, String>>> expandedData,
      long startTime, long endTime, Long[] expectedTimes) throws Exception {
    final FeedProvider fp = Mockito.mock(FeedProvider.class);
    final String feedId = "feedId";
    Mockito.when(fp.getSubscriptionId()).thenReturn(feedId);
    PlotViewManifestation manifestation = new PlotViewManifestation(mockComponent,new ViewInfo(PlotViewManifestation.class,"",ViewType.OBJECT)) {
      private static final long serialVersionUID = 1L;

      @Override
      public Collection<FeedProvider> getVisibleFeedProviders() {
        return Collections.singleton(fp);
      }
     
      @Override
      public long getCurrentMCTTime() {
        return 7L;
      }
    };
    Mockito.when(fp.getTimeService()).thenReturn(timeService);

    Method m = PlotViewManifestation.class.getDeclaredMethod("expandData", Map.class, Long.TYPE, Long.TYPE);
    m.setAccessible(true);
    m.invoke(manifestation, expandedData,startTime, endTime);
    List<Map<String, String>> values = expandedData.get(feedId);
    Assert.assertEquals(values.size(), expectedTimes.length);
    int i = 0;
    for (Map<String,String> point : values) {
      Assert.assertEquals(expectedTimes[i++].toString(),point.get(FeedProvider.NORMALIZED_TIME_KEY));
    }
  }
 
  @Test
  public void testGetMaxAndMinTimesWorksWhenTimeDirectionChanged() {
    PlotSettings settings = new PlotSettings();
    settings.setMinTime(0);
    settings.setMaxTime(100);
    settings.setXAxisMaximumLocation(XAxisMaximumLocationSetting.MAXIMUM_AT_RIGHT);
   
    PlotView plotMaxAtRight = new PlotView.Builder(PlotterPlot.class).plotSettings(settings).build();
   
   
    Assert.assertEquals(plotMaxAtRight.getMaxTime(), 100);
    Assert.assertEquals(plotMaxAtRight.getMinTime(), 0);
   
    settings.setXAxisMaximumLocation(XAxisMaximumLocationSetting.MAXIMUM_AT_LEFT);
   
    PlotView plotMaxAtLeft = new PlotView.Builder(PlotterPlot.class).plotSettings(settings).build();
   
    Assert.assertEquals(plotMaxAtLeft.getMaxTime(), 100);
    Assert.assertEquals(plotMaxAtLeft.getMinTime(), 0);
   
    settings.setAxisOrientationSetting(AxisOrientationSetting.Y_AXIS_AS_TIME);
    settings.setYAxisMaximumLocation(YAxisMaximumLocationSetting.MAXIMUM_AT_TOP);
    settings.setTimeAxisSubsequentSetting(TimeAxisSubsequentBoundsSetting.SCRUNCH);
   
    PlotView plotTimeOnYMaxAtTop = new PlotView.Builder(PlotterPlot.class).plotSettings(settings).build();
   
    Assert.assertEquals(plotTimeOnYMaxAtTop.getMaxTime(), 100);
    Assert.assertEquals(plotTimeOnYMaxAtTop.getMinTime(), 0);

    settings.setYAxisMaximumLocation(YAxisMaximumLocationSetting.MAXIMUM_AT_BOTTOM);
   
    PlotView plotTimeOnYMaxAtBottom = new PlotView.Builder(PlotterPlot.class).plotSettings(settings).build();
   
    Assert.assertEquals(plotTimeOnYMaxAtBottom.getMaxTime(), 100);
    Assert.assertEquals(plotTimeOnYMaxAtBottom.getMinTime(), 0)
  }
 
  @Test
  public void testInitializeControlManifestation() {
    PlotViewManifestation pvm = new PlotViewManifestation(mockComponent, new ViewInfo(PlotViewManifestation.class,"",ViewType.OBJECT));
   
    JComponent controlMan = pvm.initializeControlManifestation();
    Assert.assertNotNull(controlMan);
  }
 
 
  private String naming;
  @Test
  public void testNamingContext() throws Exception{
    PlotViewManifestation manifestation = new PlotViewManifestation(mockComponent, new ViewInfo(PlotViewManifestation.class,"",ViewType.OBJECT));
   
    Field f = PlotViewManifestation.class.getDeclaredField("plotLabelingAlgorithm");
    f.setAccessible(true);
    f.set(manifestation, new AbbreviatingPlotLabelingAlgorithm() {
      @Override
      public void setCanvasContextTitleList(List<String> s) { if(!s.isEmpty()) naming = s.get(0); }
      public void setPanelContextTitleList(List<String> s) { if(!s.isEmpty()) naming = s.get(0); }
    });
   
    NamingContext nullContext = Mockito.mock(NamingContext.class);
    NamingContext blankContext = Mockito.mock(NamingContext.class);
    NamingContext specificContext = Mockito.mock(NamingContext.class);
   
    PropertyChangeEvent event = Mockito.mock(PropertyChangeEvent.class);
   
    Mockito.when(nullContext.getContextualName()).thenReturn(null);
    Mockito.when(blankContext.getContextualName()).thenReturn("");
    Mockito.when(specificContext.getContextualName()).thenReturn("Specific");
   
    manifestation.setNamingContext(nullContext);
    manifestation.updateMonitoredGUI(event);
    Assert.assertEquals(naming, "");
   
    manifestation.setNamingContext(blankContext);
    manifestation.updateMonitoredGUI(event);
    Assert.assertEquals(naming, manifestation.getManifestedComponent().getDisplayName());
   
    manifestation.setNamingContext(specificContext);
    manifestation.updateMonitoredGUI(event);
    Assert.assertEquals(naming, "Specific");
   
    manifestation.setNamingContext(null);
    manifestation.updateMonitoredGUI(event);
    Assert.assertEquals(naming, manifestation.getManifestedComponent().getDisplayName());

  }
 
  private static final String[] TEST_TIME_SYSTEMS = { "SYSA", "SYSB", "SYSC" };
 
  @DataProvider (name = "timeSystems")
  public Object[][] createTimeSystems() {
    return new Object[][] {
        { TEST_TIME_SYSTEMS[0] } , { TEST_TIME_SYSTEMS[1] } , { TEST_TIME_SYSTEMS[2] }, { "NONE"
    };
  }
 
  @Test (dataProvider = "timeSystems")
  public void testMultipleFeedProviders(String setting) {
    PlotViewManifestation manifestation = new PlotViewManifestation(mockComponent, new ViewInfo(PlotViewManifestation.class,"",ViewType.OBJECT));
   
    manifestation.getViewProperties().setProperty(PlotConstants.TIME_SYSTEM_SETTING, setting);
   
    List<FeedProvider> fps = new ArrayList<FeedProvider>();
    for (String timeSys : TEST_TIME_SYSTEMS) {
      TimeService ts = Mockito.mock(TimeService.class);
      Mockito.when(ts.getTimeSystemId()).thenReturn(timeSys);
      FeedProvider fp = Mockito.mock(FeedProvider.class);
      Mockito.when(fp.getTimeService()).thenReturn(ts);     
      fps.add(fp);
    }
   
    AbstractComponent fpMockComponent = Mockito.mock(AbstractComponent.class);
    Mockito.when(fpMockComponent.getCapabilities(FeedProvider.class)).thenReturn(fps);
    Mockito.when(fpMockComponent.getCapability(FeedProvider.class)).thenReturn(null);
    FeedProvider fp = manifestation.getFeedProvider(fpMockComponent);
   
    if (setting.startsWith("SYS")) { // One of the expected test time systems
      Assert.assertEquals(fp.getTimeService().getTimeSystemId(), setting);
    } else { // One of the time systems that should fail.
      Assert.assertNull(fp);
    }
  }
 
  private static class DummyComponent extends AbstractComponent {
    public DummyComponent() {
      super();
    }
  }
}

TOP

Related Classes of gov.nasa.arc.mct.fastplot.view.TestPlotViewRole

TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.