06/23/05

Integrate \dot{x} = lambda * x from 0 to 1 with FE
  Substeps:  
	Evaluate model
	Take an integration step
	
Integrate 1DfemTransient test from Nox with various integrators

Unit tests:  
----------------------------------------
  DataStore:
    operators:  < <= > >= == 
      Check both DS ~= DS and DS ~= Scalar
    const operators:  < <= > >= == 
      Check both DS ~= DS and DS ~= Scalar
    dataStoreVectorToVector
    vectorToDataStoreVector
    vectorToDataStoreList
    vectorToDataStoreList w/o accuracy

  InterpolationBufferBase:
    setPoints:
      insert valid points then getNodes, check that t values are the same
      insert valid points then getNodes then getPoints at node values, verify data comes back out
      call with empty time_vec input
      call with Teuchos::null input
      call wtih x valid but xdot = Teuchos::null
      call with x valid but random xdot = Teuchos::null
      call with non-empty time_vec input and empty vectors 
      call with non-empty time_vec input and vectors of different sizes
      call with replacement data at a node and check that it was replaced correctly with getNodes and getPoints
      call with both replacement data and new data and verify it works correctly
    getPoints:
      call with empty time_vec input
      call with values getween nodes and verify that time value is between nodes
        verify that if x != null then x_out != null (same for xdot)
      call with NULLs for output
      call with partially filled vectors
    setRange:
      call with another IB and then check with getNodes and getPoints
      test time_lower and time_upper values for correctness of bound checking
        use valid and invalid ranges
      test empty IB passed in
    getNodes:
      call with null ptr
      call with partially filled vector
    removeNodes:
      call and then then verify nodes are gone with getNodes
      call with empty vector
       
  InterpolationBuffer:
    initialize:
      test normal procedure
      test calling midstream
      check that IBPolicy is reset
    SetInterpolator:
      test changing interpolator midstream
      verify Teuchos::null results in linear interpolator
    SetStorage:
      test lowering storage_limit when its already full
      test raising storage_limit when its full and adding points
      test lower bounds on storage
    (in addition to testing on base class), test:
    setPoints:  
      call with IBPolicy=BUFFER_STATIC and verify it returns failure when full
      call with both replacement data and new data that will exceed storage_limit
      test that storage_limit is observed
    setPoints w/o accuracy:
      call and verify points were set with accuracy set to zero.
    getPoints: nothing new
    setRange:  
      setRange with IBPolicy=BUFFER_STATIC and incoming IB inside range has too many points
      setRange with IBPolicy=BUFFER_KEEP_NEW and verify it removes nodes at beginning when full
      test that storage_limit is observed
      call with replacement nodes and new nodes that will exceed storage_limit
      call with higher order IB than local interpolator and see if it adds extra points correctly
    getNodes:  nothing new
    removeNodes:  nothing new
    
  InterpolationBufferAsStepper:
    setInterpolationBuffer:
      try changing to uninitialized IB mid stream 
      try changing to IB with data before and after current stepper's time 
      try changing to IB with data long before current stepper time
      try changing to IB with data long after current stepper time
    setStepper:
      try changing to an uninitialized stepper mid stream 
      try initializing a new stepper with the same time points as the old stepper and changing over to it midstream
      try initializing a new stepper with time before end of IB's
      try initializing a new stepper with time before beginning of IB's
      try initializing a new stepper with time after end of IB's
    (in addition to testing on base class), test:
    setPoints: nothing new
    getPoints: 
      verify the IB is initialized correctly 
      verify the stepper is initialized correctly
      verify you get data from IB correctly
      verify you get data from stepper correctly
      call with points from IB and stepper and verify you get all the right points
      call with points from IB and stepper and new points and verify you get all the right points from the right sources
    setRange:  nothing new
    getNodes:  nothing new
    removeNodes:  nothing new

  StepperBase:
    takeStep(dt):
    takeStep():
    get_solution:
    (in addition to testing on base class), test:
    setPoints:
    getPoints:
    setRange:
    getNodes:
    removeNodes:
  BackwardEulerStepper:
  ForwardEulerStepper:
  ExplicitRKStepper:
  ImplicitBDFStepper:

  InterpolatorBase:
    interpolate:
      call with valid inputs & outputs and verify output t values match input t values
      call with empty DataStore vector input
      call with empty time input vector
      call with null pointer for output DataStore vector
      call with t values outside range of input DataStore vector
      call with t values equal to input DataStore t values and verify output equals input.
      compare performance:
        Large DataStore input vector with Small time values vector 
        Small DataStore input vector with Large time values vector
        Small DataStore input vector with Small time values vector
        Large DataStore input vector with Large time values vector

  LinearInterpolator:
    (in addition to testing on base class), test:
    interpolate:
      verify interpolation is indeed linear.
      
  
  HermiteInterpolator:
    (in addition to testing on base class), test:
    interpolate:
      verify interpolation is indeed quadratic in x and linear in xdot.




