code: func NewFullFake(t Transient, initial *states.State) Full {
  	if t == nil {
  		t = NewTransientInMemory(nil)
  	}
  
  	// The "persistent" part of our manager is actually just another in-memory
  	// transient used to fake a secondary storage layer.
  	fakeP := NewTransientInMemory(initial.DeepCopy())
  
  	return &fakeFull{
  		t:     t,
  		fakeP: fakeP,
  	}
  }
docs: // NewFullFake returns a full state manager that really only supports transient
  // snapshots. This is primarily intended for testing and is not suitable for
  // general use.
  //
  // The persistent part of the interface is stubbed out as an in-memory store,
  // and so its snapshots are effectively also transient.
  //
  // The given Transient implementation is used to implement the transient
  // portion of the interface. If nil is given, NewTransientInMemory is
  // automatically called to create an in-memory transient manager with no
  // initial transient snapshot.
  //
  // If the given initial state is non-nil then a copy of it will be used as
  // the initial persistent snapshot.
  //
  // The Locker portion of the returned manager uses a local mutex to simulate
  // mutually-exclusive access to the fake persistent portion of the object.