diff --git a/pvDataApp/factory/Compare.cpp b/pvDataApp/factory/Compare.cpp
index f668d83..12a80f9 100644
--- a/pvDataApp/factory/Compare.cpp
+++ b/pvDataApp/factory/Compare.cpp
@@ -80,12 +80,15 @@ bool operator==(const Structure& a, const Structure& b)
     for (size_t i = 0; i < nflds; i++)
         if (*(af[i].get()) != *(bf[i].get()))
             return false;
-     return true;
+
+    StringArray an = a.getFieldNames();
+    StringArray bn = b.getFieldNames();
+    return std::equal( an.begin(), an.end(), bn.begin() );
 }
 
 bool operator==(const StructureArray& a, const StructureArray& b)
 {
-    return a.getStructure()==b.getStructure();
+    return *(a.getStructure().get())==*(b.getStructure().get());
 }
 
 namespace nconvert {
diff --git a/pvDataApp/factory/Convert.cpp b/pvDataApp/factory/Convert.cpp
index 23ae619..39d862e 100644
--- a/pvDataApp/factory/Convert.cpp
+++ b/pvDataApp/factory/Convert.cpp
@@ -30,7 +30,7 @@ static String illegalScalarType("Illegal ScalarType");
 static ConvertPtr convert;
 
 template<typename T>
-T toScalar(PVScalarPtr &pv)
+T toScalar(PVScalarPtr const &pv)
 {
     ScalarConstPtr scalar = pv->getScalar();
     ScalarType scalarType = scalar->getScalarType();
@@ -83,52 +83,52 @@ T toScalar(PVScalarPtr &pv)
     throw std::logic_error(logicError);
 }
 
-int8 Convert::toByte(PVScalarPtr & pv)
+int8 Convert::toByte(PVScalarPtr const & pv)
 {
      return toScalar<int8>(pv);
 }
 
-int16 Convert::toShort(PVScalarPtr & pv)
+int16 Convert::toShort(PVScalarPtr const & pv)
 {
      return toScalar<int16>(pv);
 }
 
-int32 Convert::toInt(PVScalarPtr & pv)
+int32 Convert::toInt(PVScalarPtr const & pv)
 {
      return toScalar<int32>(pv);
 }
 
-int64 Convert::toLong(PVScalarPtr & pv)
+int64 Convert::toLong(PVScalarPtr const & pv)
 {
      return toScalar<int64>(pv);
 }
 
-uint8 Convert::toUByte(PVScalarPtr & pv)
+uint8 Convert::toUByte(PVScalarPtr const & pv)
 {
      return toScalar<uint8>(pv);
 }
 
-uint16 Convert::toUShort(PVScalarPtr & pv)
+uint16 Convert::toUShort(PVScalarPtr const & pv)
 {
      return toScalar<uint16>(pv);
 }
 
-uint32 Convert::toUInt(PVScalarPtr & pv)
+uint32 Convert::toUInt(PVScalarPtr const & pv)
 {
      return toScalar<uint32>(pv);
 }
 
-uint64 Convert::toULong(PVScalarPtr &pv)
+uint64 Convert::toULong(PVScalarPtr const &pv)
 {
      return toScalar<uint64>(pv);
 }
 
-float Convert::toFloat(PVScalarPtr &pv)
+float Convert::toFloat(PVScalarPtr const &pv)
 {
      return toScalar<float>(pv);
 }
 
-double Convert::toDouble(PVScalarPtr& pv)
+double Convert::toDouble(PVScalarPtr const & pv)
 {
      return toScalar<double>(pv);
 }
@@ -222,7 +222,7 @@ String scalarToString<double>(double value)
 }
 
 template<typename T>
-void fromScalar(PVScalarPtr &pv,T from)
+void fromScalar(PVScalarPtr const &pv,T from)
 {
     ScalarConstPtr scalar = pv->getScalar();
     ScalarType scalarType = scalar->getScalarType();
@@ -279,52 +279,52 @@ void fromScalar(PVScalarPtr &pv,T from)
     throw std::logic_error(logicError);
 }
 
-void Convert::fromByte(PVScalarPtr &pv,int8 from)
+void Convert::fromByte(PVScalarPtr const &pv,int8 from)
 {
      fromScalar<int8>(pv,from);
 }
 
-void  Convert::fromShort(PVScalarPtr &pv,int16 from)
+void  Convert::fromShort(PVScalarPtr const &pv,int16 from)
 {
     fromScalar<int16>(pv,from);
 }
 
-void  Convert::fromInt(PVScalarPtr &pv, int32 from)
+void  Convert::fromInt(PVScalarPtr const &pv, int32 from)
 {
     fromScalar<int32>(pv,from);
 }
 
-void  Convert::fromLong(PVScalarPtr &pv, int64 from)
+void  Convert::fromLong(PVScalarPtr const &pv, int64 from)
 {
     fromScalar<int64>(pv,from);
 }
 
-void Convert::fromUByte(PVScalarPtr &pv,uint8 from)
+void Convert::fromUByte(PVScalarPtr const &pv,uint8 from)
 {
      fromScalar<uint8>(pv,from);
 }
 
-void  Convert::fromUShort(PVScalarPtr &pv,uint16 from)
+void  Convert::fromUShort(PVScalarPtr const &pv,uint16 from)
 {
     fromScalar<uint16>(pv,from);
 }
 
-void  Convert::fromUInt(PVScalarPtr &pv, uint32 from)
+void  Convert::fromUInt(PVScalarPtr const &pv, uint32 from)
 {
     fromScalar<uint32>(pv,from);
 }
 
-void  Convert::fromULong(PVScalarPtr &pv, uint64 from)
+void  Convert::fromULong(PVScalarPtr const &pv, uint64 from)
 {
     fromScalar<uint64>(pv,from);
 }
 
-void  Convert::fromFloat(PVScalarPtr &pv, float from)
+void  Convert::fromFloat(PVScalarPtr const &pv, float from)
 {
     fromScalar<float>(pv,from);
 }
 
-void  Convert::fromDouble(PVScalarPtr &pv, double from)
+void  Convert::fromDouble(PVScalarPtr const &pv, double from)
 {
     fromScalar<double>(pv,from);
 }
@@ -414,7 +414,7 @@ Convert::Convert(){}
 
 Convert::~Convert(){}
 
-void Convert::getFullName(StringBuilder buf,PVFieldPtr & pvField)
+void Convert::getFullName(StringBuilder buf,PVFieldPtr const & pvField)
 {
     buf->empty();
     *buf += pvField->getFieldName();
@@ -429,7 +429,7 @@ void Convert::getFullName(StringBuilder buf,PVFieldPtr & pvField)
     }
 }
 
-bool Convert::equals(PVFieldPtr &a,PVFieldPtr &b)
+bool Convert::equals(PVFieldPtr const &a,PVFieldPtr const &b)
 {
     return convertEquals(a.get(),b.get());
 }
@@ -439,12 +439,12 @@ bool Convert::equals(PVField &a,PVField &b)
     return convertEquals(&a,&b);
 }
 
-void Convert::getString(StringBuilder buf,PVFieldPtr & pvField,int indentLevel)
+void Convert::getString(StringBuilder buf,PVFieldPtr const & pvField,int indentLevel)
 {
     convertToString(buf,pvField.get(),indentLevel);
 }
 
-void Convert::getString(StringBuilder buf,PVFieldPtr & pvField)
+void Convert::getString(StringBuilder buf,PVFieldPtr const & pvField)
 {
     convertToString(buf,pvField.get(),0);
 }
@@ -459,7 +459,7 @@ void Convert::getString(StringBuilder buf,PVField *pvField)
     convertToString(buf,pvField,0);
 }
 
-size_t Convert::fromString(PVStructurePtr &pvStructure, StringArray const & from, size_t fromStartIndex)
+size_t Convert::fromString(PVStructurePtr const &pvStructure, StringArray const & from, size_t fromStartIndex)
 {
     size_t processed = 0;
     
@@ -500,7 +500,7 @@ size_t Convert::fromString(PVStructurePtr &pvStructure, StringArray const & from
 }
 
 
-void Convert::fromString(PVScalarPtr &pvScalar, String from)
+void Convert::fromString(PVScalarPtr const &pvScalar, String from)
 {
     ScalarConstPtr scalar = pvScalar->getScalar();
     ScalarType scalarType = scalar->getScalarType();
@@ -601,7 +601,7 @@ void Convert::fromString(PVScalarPtr &pvScalar, String from)
     throw std::logic_error(message);
 }
 
-size_t Convert::fromString(PVScalarArrayPtr &pv, String from)
+size_t Convert::fromString(PVScalarArrayPtr const &pv, String from)
 {
    if(from[0]=='[' && from[from.length()]==']') {
         size_t offset = from.rfind(']');
@@ -620,19 +620,19 @@ size_t Convert::fromString(PVScalarArrayPtr &pv, String from)
     return length;
 }
 
-size_t Convert::fromStringArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
+size_t Convert::fromStringArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
     StringArray const & from, size_t fromOffset)
 {
     return convertFromStringArray(pv.get(),offset,length,from,fromOffset);
 }
 
-size_t Convert::toStringArray(PVScalarArrayPtr & pv, size_t offset, size_t length,
+size_t Convert::toStringArray(PVScalarArrayPtr const & pv, size_t offset, size_t length,
     StringArray  const &to, size_t toOffset)
 {
     return convertToStringArray(pv.get(),offset,length,to,toOffset);
 }
 
-bool Convert::isCopyCompatible(FieldConstPtr &from, FieldConstPtr &to)
+bool Convert::isCopyCompatible(FieldConstPtr const &from, FieldConstPtr const &to)
 {
     if(from->getType()!=to->getType()) return false;
     switch(from->getType()) {
@@ -665,7 +665,7 @@ bool Convert::isCopyCompatible(FieldConstPtr &from, FieldConstPtr &to)
     throw std::logic_error(message);
 }
 
-void Convert::copy(PVFieldPtr &from,PVFieldPtr &to)
+void Convert::copy(PVFieldPtr const & from, PVFieldPtr const & to)
 {
     switch(from->getField()->getType()) {
     case scalar: 
@@ -700,7 +700,7 @@ void Convert::copy(PVFieldPtr &from,PVFieldPtr &to)
 }
 
 bool Convert::isCopyScalarCompatible(
-     ScalarConstPtr& fromField, ScalarConstPtr& toField)
+     ScalarConstPtr const & fromField, ScalarConstPtr const & toField)
 {
     ScalarType fromScalarType = fromField->getScalarType();
     ScalarType toScalarType = toField->getScalarType();
@@ -712,7 +712,7 @@ bool Convert::isCopyScalarCompatible(
     return false;
 }
 
-void Convert::copyScalar(PVScalarPtr &from, PVScalarPtr &to)
+void Convert::copyScalar(PVScalarPtr const & from, PVScalarPtr const & to)
 {
     if(to->isImmutable()) {
         if(from==to) return;
@@ -813,8 +813,8 @@ void Convert::copyScalar(PVScalarPtr &from, PVScalarPtr &to)
     throw std::logic_error(message);
 }
 
-bool Convert::isCopyScalarArrayCompatible(ScalarArrayConstPtr &fromArray,
-    ScalarArrayConstPtr &toArray)
+bool Convert::isCopyScalarArrayCompatible(ScalarArrayConstPtr const &fromArray,
+    ScalarArrayConstPtr const &toArray)
 {
     ScalarType fromType = fromArray->getElementType();
     ScalarType toType = toArray->getElementType();
@@ -826,8 +826,8 @@ bool Convert::isCopyScalarArrayCompatible(ScalarArrayConstPtr &fromArray,
     return false;
 }
 
-size_t Convert::copyScalarArray(PVScalarArrayPtr &from, size_t offset,
-    PVScalarArrayPtr &to, size_t toOffset, size_t length)
+size_t Convert::copyScalarArray(PVScalarArrayPtr const & from, size_t offset,
+    PVScalarArrayPtr const & to, size_t toOffset, size_t length)
 {
     
     if(to->isImmutable()) {
@@ -920,7 +920,7 @@ size_t Convert::copyScalarArray(PVScalarArrayPtr &from, size_t offset,
 }
 
 bool Convert::isCopyStructureCompatible(
-    StructureConstPtr &fromStruct, StructureConstPtr &toStruct)
+    StructureConstPtr const &fromStruct, StructureConstPtr const &toStruct)
 {
     FieldConstPtrArray fromFields = fromStruct->getFields();
     FieldConstPtrArray toFields = toStruct->getFields();
@@ -966,7 +966,7 @@ bool Convert::isCopyStructureCompatible(
     return true;
 }
 
-void Convert::copyStructure(PVStructurePtr &from, PVStructurePtr &to)
+void Convert::copyStructure(PVStructurePtr const & from, PVStructurePtr const & to)
 {
     if(to->isImmutable()) {
         if(from==to) return;
@@ -1053,7 +1053,7 @@ void Convert::copyStructure(PVStructurePtr &from, PVStructurePtr &to)
 }
 
 bool Convert::isCopyStructureArrayCompatible(
-    StructureArrayConstPtr &from, StructureArrayConstPtr &to)
+    StructureArrayConstPtr const &from, StructureArrayConstPtr const &to)
 {
     StructureConstPtr xxx = from->getStructure();
     StructureConstPtr yyy = to->getStructure();
@@ -1061,7 +1061,7 @@ bool Convert::isCopyStructureArrayCompatible(
 }
 
 void Convert::copyStructureArray(
-    PVStructureArrayPtr &from, PVStructureArrayPtr &to)
+    PVStructureArrayPtr const & from, PVStructureArrayPtr const & to)
 {
     if(to->isImmutable()) {
         if(from==to) return;
@@ -1093,7 +1093,7 @@ void Convert::copyStructureArray(
     to->postPut();
 }
 
-String Convert::toString(PVScalarPtr & pv)
+String Convert::toString(PVScalarPtr const & pv)
 {
     static String trueString("true");
     static String falseString("false");
@@ -1174,121 +1174,121 @@ String Convert::toString(PVScalarPtr & pv)
     throw std::logic_error(logicError);
 }
 
-size_t Convert::toByteArray(PVScalarArrayPtr  &pv, size_t offset, size_t length,
+size_t Convert::toByteArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
     int8 to[], size_t toOffset)
 {
     return convertToByteArray(pv.get(), offset, length, to, toOffset);
 }
 
-size_t Convert::toShortArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
+size_t Convert::toShortArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
     int16 to[], size_t toOffset)
 {
     return convertToShortArray(pv.get(), offset, length, to, toOffset);
 }
 
-size_t Convert::toIntArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
+size_t Convert::toIntArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
     int32 to[], size_t toOffset)
 {
     return convertToIntArray(pv.get(), offset, length, to, toOffset);
 }
 
-size_t Convert::toLongArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
+size_t Convert::toLongArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
     int64 to[], size_t toOffset)
 {
     return convertToLongArray(pv.get(), offset, length, to, toOffset);
 }
 
-size_t Convert::toUByteArray(PVScalarArrayPtr  &pv, size_t offset, size_t length,
+size_t Convert::toUByteArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
     uint8 to[], size_t toOffset)
 {
     return convertToUByteArray(pv.get(), offset, length, to, toOffset);
 }
 
-size_t Convert::toUShortArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
+size_t Convert::toUShortArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
     uint16 to[], size_t toOffset)
 {
     return convertToUShortArray(pv.get(), offset, length, to, toOffset);
 }
 
-size_t Convert::toUIntArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
+size_t Convert::toUIntArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
     uint32 to[], size_t toOffset)
 {
     return convertToUIntArray(pv.get(), offset, length, to, toOffset);
 }
 
-size_t Convert::toULongArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
+size_t Convert::toULongArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
     uint64 to[], size_t toOffset)
 {
     return convertToULongArray(pv.get(), offset, length, to, toOffset);
 }
 
-size_t Convert::toFloatArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
+size_t Convert::toFloatArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
     float to[], size_t toOffset)
 {
     return convertToFloatArray(pv.get(), offset, length, to, toOffset);
 }
 
-size_t Convert::toDoubleArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
+size_t Convert::toDoubleArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
     double to[], size_t toOffset)
 {
     return convertToDoubleArray(pv.get(), offset, length, to, toOffset);
 }
 
-size_t Convert::fromByteArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
+size_t Convert::fromByteArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
     int8 from[], size_t fromOffset)
 {
     return convertFromByteArray(pv.get(), offset, length, from, fromOffset);
 }
 
-size_t Convert::fromShortArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
+size_t Convert::fromShortArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
     int16 from[], size_t fromOffset)
 {
     return convertFromShortArray(pv.get(), offset, length, from, fromOffset);
 }
 
-size_t Convert::fromIntArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
+size_t Convert::fromIntArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
     int32 from[], size_t fromOffset)
 {
     return convertFromIntArray(pv.get(), offset, length, from, fromOffset);
 }
 
-size_t Convert::fromLongArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
+size_t Convert::fromLongArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
     int64 from[], size_t fromOffset)
 {
     return convertFromLongArray(pv.get(), offset, length, from, fromOffset);
 }
 
-size_t Convert::fromUByteArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
+size_t Convert::fromUByteArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
     uint8 from[], size_t fromOffset)
 {
     return convertFromUByteArray(pv.get(), offset, length, from, fromOffset);
 }
 
-size_t Convert::fromUShortArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
+size_t Convert::fromUShortArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
     uint16 from[], size_t fromOffset)
 {
     return convertFromUShortArray(pv.get(), offset, length, from, fromOffset);
 }
 
-size_t Convert::fromUIntArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
+size_t Convert::fromUIntArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
     uint32 from[], size_t fromOffset)
 {
     return convertFromUIntArray(pv.get(), offset, length, from, fromOffset);
 }
 
-size_t Convert::fromULongArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
+size_t Convert::fromULongArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
     uint64 from[], size_t fromOffset)
 {
     return convertFromULongArray(pv.get(), offset, length, from, fromOffset);
 }
 
-size_t Convert::fromFloatArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
+size_t Convert::fromFloatArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
     float from[], size_t fromOffset)
 {
     return convertFromFloatArray(pv.get(), offset, length, from, fromOffset);
 }
 
-size_t Convert::fromDoubleArray(PVScalarArrayPtr &pv, size_t offset, size_t length,
+size_t Convert::fromDoubleArray(PVScalarArrayPtr const &pv, size_t offset, size_t length,
     double from[], size_t fromOffset)
 {
     return convertFromDoubleArray(pv.get(), offset, length, from, fromOffset);
diff --git a/pvDataApp/factory/FieldCreateFactory.cpp b/pvDataApp/factory/FieldCreateFactory.cpp
index ddb5b51..da86d70 100644
--- a/pvDataApp/factory/FieldCreateFactory.cpp
+++ b/pvDataApp/factory/FieldCreateFactory.cpp
@@ -117,8 +117,8 @@ static StructureConstPtr deserializeStructureField(const FieldCreate* fieldCreat
     StringArray fieldNames; fieldNames.reserve(size);
     for (std::size_t i = 0; i < size; i++)
     {
-        fieldNames[i] = SerializeHelper::deserializeString(buffer, control);
-        fields[i] = control->cachedDeserialize(buffer);
+        fieldNames.push_back(SerializeHelper::deserializeString(buffer, control));
+        fields.push_back(control->cachedDeserialize(buffer));
     }
 
     return fieldCreate->createStructure(fieldNames, fields);
@@ -143,7 +143,7 @@ void ScalarArray::deserialize(ByteBuffer *buffer, DeserializableControl *control
     throw std::runtime_error("not valid operation, use FieldCreate::deserialize instead");
 }
 
-StructureArray::StructureArray(StructureConstPtr structure)
+StructureArray::StructureArray(StructureConstPtr const & structure)
 : Field(structureArray),pstructure(structure)
 {
 }
@@ -289,7 +289,7 @@ StructureConstPtr FieldCreate::createStructure (
 }
 
 StructureArrayConstPtr FieldCreate::createStructureArray(
-    StructureConstPtr structure) const
+    StructureConstPtr const & structure) const
 {
      StructureArrayConstPtr structureArray(
         new StructureArray(structure), Field::Deleter());
@@ -297,7 +297,7 @@ StructureArrayConstPtr FieldCreate::createStructureArray(
 }
 
 StructureConstPtr FieldCreate::appendField(
-    StructureConstPtr structure,String fieldName, FieldConstPtr field) const
+    StructureConstPtr const & structure,String fieldName, FieldConstPtr const & field) const
 {
     StringArray oldNames = structure->getFieldNames();
     FieldConstPtrArray oldFields = structure->getFields();
@@ -314,7 +314,7 @@ StructureConstPtr FieldCreate::appendField(
 }
 
 StructureConstPtr FieldCreate::appendFields(
-    StructureConstPtr structure,
+    StructureConstPtr const & structure,
     StringArray const & fieldNames,
     FieldConstPtrArray const & fields) const
 {
diff --git a/pvDataApp/factory/PVArray.cpp b/pvDataApp/factory/PVArray.cpp
index a7017ec..8f981ac 100644
--- a/pvDataApp/factory/PVArray.cpp
+++ b/pvDataApp/factory/PVArray.cpp
@@ -25,7 +25,7 @@ namespace epics { namespace pvData {
         bool capacityMutable;
     };
 
-    PVArray::PVArray(FieldConstPtr field)
+    PVArray::PVArray(FieldConstPtr const & field)
     : PVField(field),pImpl(new PVArrayPvt())
     { }
 
diff --git a/pvDataApp/factory/PVDataCreateFactory.cpp b/pvDataApp/factory/PVDataCreateFactory.cpp
index 915c6b3..a53d906 100644
--- a/pvDataApp/factory/PVDataCreateFactory.cpp
+++ b/pvDataApp/factory/PVDataCreateFactory.cpp
@@ -36,7 +36,7 @@ public:
     typedef T* pointer;
     typedef const T* const_pointer;
 
-    BasePVScalar(ScalarConstPtr &scalar);
+    BasePVScalar(ScalarConstPtr const & scalar);
     virtual ~BasePVScalar();
     virtual T get();
     virtual void put(T val);
@@ -49,7 +49,7 @@ private:
 };
 
 template<typename T>
-BasePVScalar<T>::BasePVScalar(ScalarConstPtr &scalar)
+BasePVScalar<T>::BasePVScalar(ScalarConstPtr const & scalar)
     : PVScalarValue<T>(scalar),value(0)
 {}
 //Note: '0' is a suitable default for all POD types (not String)
@@ -97,7 +97,7 @@ public:
     typedef String* pointer;
     typedef const String* const_pointer;
 
-    BasePVString(ScalarConstPtr &scalar);
+    BasePVString(ScalarConstPtr const & scalar);
     virtual ~BasePVString();
     virtual String get();
     virtual void put(String val);
@@ -111,7 +111,7 @@ private:
     String value;
 };
 
-BasePVString::BasePVString(ScalarConstPtr &scalar)
+BasePVString::BasePVString(ScalarConstPtr const & scalar)
     : PVString(scalar),value()
 {}
 
@@ -159,7 +159,7 @@ public:
     typedef std::vector<T> vector;
     typedef std::tr1::shared_ptr<vector> shared_vector;
 
-    DefaultPVArray(ScalarArrayConstPtr &scalarArray);
+    DefaultPVArray(ScalarArrayConstPtr const & scalarArray);
     virtual ~DefaultPVArray();
     virtual void setCapacity(size_t capacity);
     virtual size_t get(size_t offset, size_t length, PVArrayData<T> &data) ;
@@ -200,7 +200,7 @@ T *DefaultPVArray<T>::get() const
 
 
 template<typename T>
-DefaultPVArray<T>::DefaultPVArray(ScalarArrayConstPtr &scalarArray)
+DefaultPVArray<T>::DefaultPVArray(ScalarArrayConstPtr const & scalarArray)
 : PVValueArray<T>(scalarArray),
     value(std::tr1::shared_ptr<std::vector<T> >(new std::vector<T>()))
   
@@ -425,7 +425,7 @@ typedef DefaultPVArray<String> BasePVStringArray;
 
 PVDataCreate::PVDataCreate(){ }
 
-PVFieldPtr PVDataCreate::createPVField(FieldConstPtr & field)
+PVFieldPtr PVDataCreate::createPVField(FieldConstPtr const & field)
 {
      switch(field->getType()) {
      case scalar: {
@@ -448,7 +448,7 @@ PVFieldPtr PVDataCreate::createPVField(FieldConstPtr & field)
      throw std::logic_error("PVDataCreate::createPVField should never get here");
 }
 
-PVFieldPtr PVDataCreate::createPVField(PVFieldPtr & fieldToClone)
+PVFieldPtr PVDataCreate::createPVField(PVFieldPtr const & fieldToClone)
 {
      switch(fieldToClone->getField()->getType()) {
      case scalar:
@@ -484,7 +484,7 @@ PVFieldPtr PVDataCreate::createPVField(PVFieldPtr & fieldToClone)
      throw std::logic_error("PVDataCreate::createPVField should never get here");
 }
 
-PVScalarPtr PVDataCreate::createPVScalar(ScalarConstPtr & scalar)
+PVScalarPtr PVDataCreate::createPVScalar(ScalarConstPtr const & scalar)
 {
      ScalarType scalarType = scalar->getScalarType();
      switch(scalarType) {
@@ -523,7 +523,7 @@ PVScalarPtr PVDataCreate::createPVScalar(ScalarType scalarType)
 }
 
 
-PVScalarPtr PVDataCreate::createPVScalar(PVScalarPtr & scalarToClone)
+PVScalarPtr PVDataCreate::createPVScalar(PVScalarPtr const & scalarToClone)
 {
      ScalarType scalarType = scalarToClone->getScalar()->getScalarType();
      PVScalarPtr pvScalar = createPVScalar(scalarType);
@@ -542,7 +542,7 @@ PVScalarPtr PVDataCreate::createPVScalar(PVScalarPtr & scalarToClone)
 }
 
 PVScalarArrayPtr PVDataCreate::createPVScalarArray(
-        ScalarArrayConstPtr & scalarArray)
+        ScalarArrayConstPtr const & scalarArray)
 {
      switch(scalarArray->getElementType()) {
      case pvBoolean:
@@ -582,7 +582,7 @@ PVScalarArrayPtr PVDataCreate::createPVScalarArray(
 }
 
 PVScalarArrayPtr PVDataCreate::createPVScalarArray(
-        PVScalarArrayPtr &arrayToClone)
+        PVScalarArrayPtr const & arrayToClone)
 {
      PVScalarArrayPtr pvArray = createPVScalarArray(
           arrayToClone->getScalarArray()->getElementType());
@@ -601,19 +601,19 @@ PVScalarArrayPtr PVDataCreate::createPVScalarArray(
 }
 
 PVStructureArrayPtr PVDataCreate::createPVStructureArray(
-        StructureArrayConstPtr & structureArray)
+        StructureArrayConstPtr const & structureArray)
 {
      return PVStructureArrayPtr(new PVStructureArray(structureArray));
 }
 
 PVStructurePtr PVDataCreate::createPVStructure(
-        StructureConstPtr &structure)
+        StructureConstPtr const & structure)
 {
      return PVStructurePtr(new PVStructure(structure));
 }
 
 PVStructurePtr PVDataCreate::createPVStructure(
-        StringArray & fieldNames,PVFieldPtrArray & pvFields)
+        StringArray const & fieldNames,PVFieldPtrArray const & pvFields)
 {
      size_t num = fieldNames.size();
      FieldConstPtrArray fields(num);
@@ -622,7 +622,7 @@ PVStructurePtr PVDataCreate::createPVStructure(
      return PVStructurePtr(new PVStructure(structure,pvFields));
 }
 
-PVStructurePtr PVDataCreate::createPVStructure(PVStructurePtr &structToClone)
+PVStructurePtr PVDataCreate::createPVStructure(PVStructurePtr const & structToClone)
 {
     FieldConstPtrArray field;
     if(structToClone==0) {
diff --git a/pvDataApp/factory/PVScalar.cpp b/pvDataApp/factory/PVScalar.cpp
index 7c723d7..ca9e52b 100644
--- a/pvDataApp/factory/PVScalar.cpp
+++ b/pvDataApp/factory/PVScalar.cpp
@@ -17,7 +17,7 @@ namespace epics { namespace pvData {
 
     PVScalar::~PVScalar() {}
 
-    PVScalar::PVScalar(ScalarConstPtr  scalar)
+    PVScalar::PVScalar(ScalarConstPtr const & scalar)
     : PVField(scalar) {}
 
     ScalarConstPtr PVScalar::getScalar() 
diff --git a/pvDataApp/factory/PVScalarArray.cpp b/pvDataApp/factory/PVScalarArray.cpp
index ce218f6..69b1c91 100644
--- a/pvDataApp/factory/PVScalarArray.cpp
+++ b/pvDataApp/factory/PVScalarArray.cpp
@@ -17,7 +17,7 @@ namespace epics { namespace pvData {
 
     PVScalarArray::~PVScalarArray() {}
 
-    PVScalarArray::PVScalarArray(ScalarArrayConstPtr scalarArray)
+    PVScalarArray::PVScalarArray(ScalarArrayConstPtr const & scalarArray)
     : PVArray(scalarArray) {}
 
     ScalarArrayConstPtr PVScalarArray::getScalarArray() 
diff --git a/pvDataApp/factory/PVStructure.cpp b/pvDataApp/factory/PVStructure.cpp
index 744a66d..ff4df95 100644
--- a/pvDataApp/factory/PVStructure.cpp
+++ b/pvDataApp/factory/PVStructure.cpp
@@ -40,7 +40,7 @@ static PVScalarArrayPtr nullPVScalarArray;
 
 static PVFieldPtr findSubField(String fieldName,PVStructure *pvStructure);
 
-PVStructure::PVStructure(StructureConstPtr& structurePtr)
+PVStructure::PVStructure(StructureConstPtr const & structurePtr)
 : PVField(structurePtr),
   structurePtr(structurePtr),
   extendsStructureName("")
@@ -58,8 +58,8 @@ PVStructure::PVStructure(StructureConstPtr& structurePtr)
     }
 }
 
-PVStructure::PVStructure(StructureConstPtr structurePtr,
-    PVFieldPtrArray & pvs
+PVStructure::PVStructure(StructureConstPtr const & structurePtr,
+    PVFieldPtrArray const & pvs
 )
 : PVField(structurePtr),
   structurePtr(structurePtr),
@@ -112,7 +112,7 @@ PVFieldPtr  PVStructure::getSubField(size_t fieldOffset)
     throw std::logic_error("PVStructure.getSubField: Logic error");
 }
 
-void PVStructure::appendPVField(String fieldName,PVFieldPtr & pvField )
+void PVStructure::appendPVField(String fieldName, PVFieldPtr const & pvField)
 {
     size_t origLength = pvFields.size();
     size_t newLength = origLength+1;
@@ -132,7 +132,7 @@ void PVStructure::appendPVField(String fieldName,PVFieldPtr & pvField )
     }
 }
 
-void PVStructure::appendPVFields(StringArray &fieldNames,PVFieldPtrArray &pvFields)
+void PVStructure::appendPVFields(StringArray const & fieldNames, PVFieldPtrArray const & pvFields)
 {
     size_t origLength = this->pvFields.size();
     size_t extra = fieldNames.size();
diff --git a/pvDataApp/factory/PVStructureArray.cpp b/pvDataApp/factory/PVStructureArray.cpp
index 8d6ea9e..dc36b75 100644
--- a/pvDataApp/factory/PVStructureArray.cpp
+++ b/pvDataApp/factory/PVStructureArray.cpp
@@ -19,7 +19,7 @@ using std::size_t;
 
 namespace epics { namespace pvData {
 
-PVStructureArray::PVStructureArray(StructureArrayConstPtr structureArray)
+PVStructureArray::PVStructureArray(StructureArrayConstPtr const & structureArray)
 : PVArray(structureArray),
   structureArray(structureArray),
   value(std::tr1::shared_ptr<std::vector<PVStructurePtr> >
diff --git a/pvDataApp/factory/StandardField.cpp b/pvDataApp/factory/StandardField.cpp
index 86f1f26..ecc8fa9 100644
--- a/pvDataApp/factory/StandardField.cpp
+++ b/pvDataApp/factory/StandardField.cpp
@@ -505,7 +505,7 @@ StructureConstPtr StandardField::scalarArray(
 
 
 StructureConstPtr StandardField::structureArray(
-    StructureConstPtr &structure,String properties)
+    StructureConstPtr const & structure,String properties)
 {
     StructureArrayConstPtr field = fieldCreate->createStructureArray(
         structure);
diff --git a/pvDataApp/pv/convert.h b/pvDataApp/pv/convert.h
index d67b995..95722c4 100644
--- a/pvDataApp/pv/convert.h
+++ b/pvDataApp/pv/convert.h
@@ -73,7 +73,7 @@ public:
      * @param builder The builder that will have the result.
      * @param pvField The pvField.
      */
-    void getFullName(StringBuilder buf,PVFieldPtr & pvField);
+    void getFullName(StringBuilder buf,PVFieldPtr const & pvField);
     /**
      * Do fields have the same definition.
      *
@@ -81,7 +81,7 @@ public:
      * @param  Second field
      * @return (false, true) if the fields (are not, are) the same.
      */
-    bool equals(PVFieldPtr &a,PVFieldPtr &b);
+    bool equals(PVFieldPtr const &a,PVFieldPtr const &b);
     /**
      * Do fields have the same definition.
      *
@@ -97,14 +97,14 @@ public:
      * If a PVField is a structure or array be prepared for a very long string.
      * @param indentLevel indentation level
      */
-    void getString(StringBuilder buf,PVFieldPtr & pvField,int indentLevel);
+    void getString(StringBuilder buf,PVFieldPtr const & pvField,int indentLevel);
     /**
      * Convert a PVField to a string.
      * param buf buffer for the result
      * @param pv The PVField to convert to a string.
      * If the PVField is a structure or array be prepared for a very long string.
      */
-    void getString(StringBuilder buf,PVFieldPtr & pvField);
+    void getString(StringBuilder buf,PVFieldPtr const & pvField);
     /**
      * Convert a PVField to a string.
      * @param buf buffer for the result
@@ -127,14 +127,14 @@ public:
       * @param fromStartIndex The first element if the array of strings.
       * @throws std::logic_error if the array of String does not have a valid values.
       */
-    std::size_t fromString(PVStructurePtr &pv, StringArray const & from, std::size_t fromStartIndex = 0);    
+    std::size_t fromString(PVStructurePtr const &pv, StringArray const & from, std::size_t fromStartIndex = 0);
      /**
      * Convert from a String to a PVScalar
      * @param pv The PV.
      * @param from The String value to convert and put into a PV.
      * @throws std::logic_error if the String does not have a valid value.
      */
-    void fromString(PVScalarPtr & pv, String from);
+    void fromString(PVScalarPtr const & pv, String from);
     /**
      * Convert  from a String to a PVScalarArray.
      * The String must be a comma separated set of values optionally enclosed in []
@@ -144,7 +144,7 @@ public:
      * @throws std::invalid_argument if the element Type is not a scalar.
      * @throws std::logic_error if the String does not have a valid array values.
      */
-    std::size_t fromString(PVScalarArrayPtr & pv, String from);
+    std::size_t fromString(PVScalarArrayPtr const & pv, String from);
     /**
      * Convert a PVScalarArray from a String array.
      * The array element type must be a scalar.
@@ -157,7 +157,7 @@ public:
      * @throws std::invalid_argument if the element Type is not a scalar.
      * @throws std::logic_error if the String does not have a valid value.
      */
-    std::size_t fromStringArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
+    std::size_t fromStringArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
         StringArray const & from, std::size_t fromOffset);
     /**
      * Convert a PVScalarArray to a String array.
@@ -168,7 +168,7 @@ public:
      * @param toOffset Starting element in the string array.
      * @return Number of elements converted.
      */
-    std::size_t toStringArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
+    std::size_t toStringArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
         StringArray const & to, std::size_t toOffset);
     /**
      * Are from and to valid arguments to copy.
@@ -179,7 +179,7 @@ public:
      * @param to The destination.
      * @return (false,true) is the arguments (are not, are) compatible.
      */
-    bool isCopyCompatible(FieldConstPtr & from, FieldConstPtr & to);
+    bool isCopyCompatible(FieldConstPtr const & from, FieldConstPtr const & to);
     /**
      * Copy from a PVField to another PVField.
      * This calls one on copyScalar, copyArray, copyStructure.
@@ -188,7 +188,7 @@ public:
      * @param to The destination
      * @throws std::invalid_argument if the arguments are not compatible.
      */
-    void copy(PVFieldPtr & from,PVFieldPtr & to);
+    void copy(PVFieldPtr const & from, PVFieldPtr const & to);
     /**
      * Are from and to valid arguments to copyScalar.
      * false will be returned if either argument is not a scalar as defined by Type.isScalar().
@@ -203,14 +203,14 @@ public:
      * @return (false,true) If the arguments (are not, are) compatible.
      */
     bool isCopyScalarCompatible(
-         ScalarConstPtr & from, ScalarConstPtr & to);
+         ScalarConstPtr const & from, ScalarConstPtr const & to);
     /**
      * Copy from a scalar pv to another scalar pv.
      * @param from the source.
      * @param to the destination.
      * @throws std::invalid_argument if the arguments are not compatible.
      */
-    void copyScalar(PVScalarPtr & from, PVScalarPtr & to);
+    void copyScalar(PVScalarPtr const & from, PVScalarPtr const & to);
     /**
      * Are from and to valid arguments to copyArray.
      * The results are like isCopyScalarCompatible except that the tests are made on the elementType.
@@ -218,8 +218,8 @@ public:
      * @param to The to array.
      * @return (false,true) If the arguments (are not, are) compatible.
      */
-    bool isCopyScalarArrayCompatible(ScalarArrayConstPtr & from,
-        ScalarArrayConstPtr & to);
+    bool isCopyScalarArrayCompatible(ScalarArrayConstPtr const & from,
+        ScalarArrayConstPtr const & to);
     /**
      * Convert from a source PV array to a destination PV array.
      * @param from The source array.
@@ -230,8 +230,8 @@ public:
      * @return Number of elements converted.
      * @throws std::invalid_argument if the arguments are not compatible.
      */
-    std::size_t copyScalarArray(PVScalarArrayPtr & from, std::size_t offset,
-        PVScalarArrayPtr & to, std::size_t toOffset, std::size_t length);
+    std::size_t copyScalarArray(PVScalarArrayPtr const & from, std::size_t offset,
+        PVScalarArrayPtr const & to, std::size_t toOffset, std::size_t length);
     /**
      * Are from and to valid arguments for copyStructure.
      * They are only compatible if they have the same Structure description.
@@ -240,7 +240,7 @@ public:
      * @return (false,true) If the arguments (are not, are) compatible.
      */
     bool isCopyStructureCompatible(
-        StructureConstPtr & from, StructureConstPtr & to);
+        StructureConstPtr const & from, StructureConstPtr const & to);
     /**
      * Copy from a structure pv to another structure pv.
      * NOTE: Only compatible nodes are copied. This means:
@@ -254,7 +254,7 @@ public:
      * @param to The destination.
      * @throws std::invalid_argument if the arguments are not compatible.
      */
-    void copyStructure(PVStructurePtr & from, PVStructurePtr & to);
+    void copyStructure(PVStructurePtr const & from, PVStructurePtr const & to);
     /**
      * Are from and to valid for copyStructureArray.
      * @param from The from StructureArray.
@@ -262,158 +262,158 @@ public:
      * @return (false,true) If the arguments (are not, are) compatible.
      */
     bool isCopyStructureArrayCompatible(
-        StructureArrayConstPtr & from, StructureArrayConstPtr & to);
+        StructureArrayConstPtr const & from, StructureArrayConstPtr const & to);
      /**
       * Copy from a structure array to another structure array.
       * @param from The source array.
       * @param to The destination array.
       */
     void copyStructureArray(
-        PVStructureArrayPtr & from, PVStructureArrayPtr & to);
+        PVStructureArrayPtr const & from, PVStructureArrayPtr const & to);
     /**
      * Convert a PV to a <byte>.
      * @param pv a PV
      * @return converted value
      */
-    int8 toByte(PVScalarPtr & pv);
+    int8 toByte(PVScalarPtr const & pv);
     /**
      * Convert a PV to a short.
      * @param pv a PV
      * @return converted value
      * @throws std::invalid_argument if the Type is not a numeric scalar
      */
-    int16 toShort(PVScalarPtr & pv);
+    int16 toShort(PVScalarPtr const & pv);
     /**
      * Convert a PV to a int.
      * @param pv a PV
      * @return converted value
      * @throws std::invalid_argument if the Type is not a numeric scalar
      */
-    int32 toInt(PVScalarPtr & pv);
+    int32 toInt(PVScalarPtr const & pv);
     /**
      * Convert a PV to an long
      * @param pv a PV
      * @return converted value
      * @throws std::invalid_argument if the Type is not a numeric scalar
      */
-    int64 toLong(PVScalarPtr & pv);
+    int64 toLong(PVScalarPtr const & pv);
     /**
      * Convert a PV to a ubyte.
      * @param pv a PV
      * @return converted value
      */
-    uint8 toUByte(PVScalarPtr & pv);
+    uint8 toUByte(PVScalarPtr const & pv);
     /**
      * Convert a PV to a ushort.
      * @param pv a PV
      * @return converted value
      * @throws std::invalid_argument if the Type is not a numeric scalar
      */
-    uint16 toUShort(PVScalarPtr & pv);
+    uint16 toUShort(PVScalarPtr const & pv);
     /**
      * Convert a PV to a uint.
      * @param pv a PV
      * @return converted value
      * @throws std::invalid_argument if the Type is not a numeric scalar
      */
-    uint32 toUInt(PVScalarPtr & pv);
+    uint32 toUInt(PVScalarPtr const & pv);
     /**
      * Convert a PV to an ulong
      * @param pv a PV
      * @return converted value
      * @throws std::invalid_argument if the Type is not a numeric scalar
      */
-    uint64 toULong(PVScalarPtr & pv);
+    uint64 toULong(PVScalarPtr const & pv);
     /**
      * Convert a PV to a float
      * @param pv a PV
      * @return converted value
      * @throws std::invalid_argument if the Type is not a numeric scalar
      */
-    float toFloat(PVScalarPtr & pv);
+    float toFloat(PVScalarPtr const & pv);
     /**
      * Convert a PV to a double
      * @param pv a PV
      * @return converted value
      * @throws std::invalid_argument if the Type is not a numeric scalar
      */
-    double toDouble(PVScalarPtr & pv);
+    double toDouble(PVScalarPtr const & pv);
     /**
      * Convert a PV to a String
      * @param pv a PV
      * @return converted value
      */
-    String toString(PVScalarPtr & pv);
+    String toString(PVScalarPtr const & pv);
     /**
      * Convert a PV from a byte
      * @param pv a PV
      * @param from value to put into PV
      * @throws std::invalid_argument if the Type is not a numeric scalar
      */
-    void fromByte(PVScalarPtr & pv,int8 from);
+    void fromByte(PVScalarPtr const & pv,int8 from);
     /**
      * Convert a PV from a short
      * @param pv a PV
      * @param from value to put into PV
      * @throws std::invalid_argument if the Type is not a numeric scalar
      */
-    void fromShort(PVScalarPtr & pv,int16 from);
+    void fromShort(PVScalarPtr const & pv,int16 from);
     /**
      * Convert a PV from an int
      * @param pv a PV
      * @param from value to put into PV
      * @throws std::invalid_argument if the Type is not a numeric scalar
      */
-    void fromInt(PVScalarPtr & pv, int32 from);
+    void fromInt(PVScalarPtr const & pv, int32 from);
     /**
      * Convert a PV from a long
      * @param pv a PV
      * @param from value to put into PV
      * @throws std::invalid_argument if the Type is not a numeric scalar
      */
-    void fromLong(PVScalarPtr & pv, int64 from);
+    void fromLong(PVScalarPtr const & pv, int64 from);
     /**
      * Convert a PV from a ubyte
      * @param pv a PV
      * @param from value to put into PV
      * @throws std::invalid_argument if the Type is not a numeric scalar
      */
-    void fromUByte(PVScalarPtr & pv,uint8 from);
+    void fromUByte(PVScalarPtr const & pv,uint8 from);
     /**
      * Convert a PV from a ushort
      * @param pv a PV
      * @param from value to put into PV
      * @throws std::invalid_argument if the Type is not a numeric scalar
      */
-    void fromUShort(PVScalarPtr & pv,uint16 from);
+    void fromUShort(PVScalarPtr const & pv,uint16 from);
     /**
      * Convert a PV from an uint
      * @param pv a PV
      * @param from value to put into PV
      * @throws std::invalid_argument if the Type is not a numeric scalar
      */
-    void fromUInt(PVScalarPtr & pv, uint32 from);
+    void fromUInt(PVScalarPtr const & pv, uint32 from);
     /**
      * Convert a PV from a ulong
      * @param pv a PV
      * @param from value to put into PV
      * @throws std::invalid_argument if the Type is not a numeric scalar
      */
-    void fromULong(PVScalarPtr & pv, uint64 from);
+    void fromULong(PVScalarPtr const & pv, uint64 from);
     /**
      * Convert a PV from a float
      * @param pv a PV
      * @param from value to put into PV
      * @throws std::invalid_argument if the Type is not a numeric scalar
      */
-    void fromFloat(PVScalarPtr & pv, float from);
+    void fromFloat(PVScalarPtr const & pv, float from);
     /**
      * Convert a PV from a double
      * @param pv a PV
      * @param from value to put into PV
      * @throws std::invalid_argument if the Type is not a numeric scalar
      */
-    void fromDouble(PVScalarPtr & pv, double from);
+    void fromDouble(PVScalarPtr const & pv, double from);
     /**
      * Convert a PV array to a byte array.
      * @param pv a PV
@@ -424,7 +424,7 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
-    std::size_t toByteArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
+    std::size_t toByteArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
         int8* to, std::size_t toOffset);
     /**
      * Convert a PV array to a short array.
@@ -436,7 +436,7 @@ public:
      * @return number of elements converted
     * @throws std::invalid_argument if the element type is not numeric
     */
-    std::size_t toShortArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
+    std::size_t toShortArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
         int16* to, std::size_t toOffset);
     /**
      * Convert a PV array to an int array.
@@ -448,7 +448,7 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
-    std::size_t toIntArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
+    std::size_t toIntArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
         int32* to, std::size_t toOffset);
     /**
      * Convert a PV array to a long array.
@@ -460,7 +460,7 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
-    std::size_t toLongArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
+    std::size_t toLongArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
         int64* to, std::size_t toOffset);
     /**
      * Convert a PV array to a ubyte array.
@@ -472,7 +472,7 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
-    std::size_t toUByteArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
+    std::size_t toUByteArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
         uint8* to, std::size_t toOffset);
     /**
      * Convert a PV array to a ushort array.
@@ -484,7 +484,7 @@ public:
      * @return number of elements converted
     * @throws std::invalid_argument if the element type is not numeric
     */
-    std::size_t toUShortArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
+    std::size_t toUShortArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
         uint16* to, std::size_t toOffset);
     /**
      * Convert a PV array to an uint array.
@@ -496,7 +496,7 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
-    std::size_t toUIntArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
+    std::size_t toUIntArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
         uint32* to, std::size_t toOffset);
     /**
      * Convert a PV array to a ulong array.
@@ -508,7 +508,7 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
-    std::size_t toULongArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
+    std::size_t toULongArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
         uint64* to, std::size_t toOffset);
      /**
       * Convert a PV array to a float array.
@@ -520,7 +520,7 @@ public:
       * @return number of elements converted
       * @throws std::invalid_argument if the element type is not numeric
       */
-    std::size_t toFloatArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
+    std::size_t toFloatArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
         float* to, std::size_t toOffset);
     /**
      * Convert a PV array to a double array.
@@ -532,7 +532,7 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
-    std::size_t toDoubleArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
+    std::size_t toDoubleArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
         double* to, std::size_t toOffset);
     /**
      * Convert a PV array from a byte array.
@@ -544,7 +544,7 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
-    std::size_t fromByteArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
+    std::size_t fromByteArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
         int8* frim, std::size_t fromOffset);
     /**
      * Convert a PV array from a short array.
@@ -556,7 +556,7 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
-    std::size_t fromShortArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
+    std::size_t fromShortArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
         int16* frim, std::size_t fromOffset);
     /**
      * Convert a PV array from an int array.
@@ -568,7 +568,7 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
-    std::size_t fromIntArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
+    std::size_t fromIntArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
        int32* frim, std::size_t fromOffset);
     /**
      * Convert a PV array from a long array.
@@ -580,7 +580,7 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
-    std::size_t fromLongArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
+    std::size_t fromLongArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
         int64* frim, std::size_t fromOffset);
     /**
      * Convert a PV array from a ubyte array.
@@ -592,7 +592,7 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
-    std::size_t fromUByteArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
+    std::size_t fromUByteArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
         uint8* frim, std::size_t fromOffset);
     /**
      * Convert a PV array from a ushort array.
@@ -604,7 +604,7 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
-    std::size_t fromUShortArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
+    std::size_t fromUShortArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
         uint16* frim, std::size_t fromOffset);
     /**
      * Convert a PV array from an uint array.
@@ -616,7 +616,7 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
-    std::size_t fromUIntArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
+    std::size_t fromUIntArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
        uint32* frim, std::size_t fromOffset);
     /**
      * Convert a PV array from a ulong array.
@@ -628,7 +628,7 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
-    std::size_t fromULongArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
+    std::size_t fromULongArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
         uint64* frim, std::size_t fromOffset);
     /**
      * Convert a PV array from a float array.
@@ -640,7 +640,7 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
-    std::size_t fromFloatArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
+    std::size_t fromFloatArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
         float* frim, std::size_t fromOffset);
     /**
      * Convert a PV array from a double array.
@@ -652,7 +652,7 @@ public:
      * @return number of elements converted
      * @throws std::invalid_argument if the element type is not numeric
      */
-    std::size_t fromDoubleArray(PVScalarArrayPtr & pv, std::size_t offset, std::size_t length,
+    std::size_t fromDoubleArray(PVScalarArrayPtr const & pv, std::size_t offset, std::size_t length,
         double* frim, std::size_t fromOffset);
     /**
      * Convenience method for implementing toString.
diff --git a/pvDataApp/pv/pvData.h b/pvDataApp/pv/pvData.h
index 5bc43d9..4b2ce1c 100644
--- a/pvDataApp/pv/pvData.h
+++ b/pvDataApp/pv/pvData.h
@@ -292,7 +292,7 @@ public:
      */
     ScalarConstPtr getScalar() ;
 protected:
-    PVScalar(ScalarConstPtr  scalar);
+    PVScalar(ScalarConstPtr const & scalar);
 };
 
 /**
@@ -320,7 +320,7 @@ public:
      */
     virtual void put(T value) = 0;
 protected:
-    PVScalarValue(ScalarConstPtr  scalar)
+    PVScalarValue(ScalarConstPtr const & scalar)
     : PVScalar(scalar) {}
 private:
     friend class PVDataCreate;
@@ -362,7 +362,7 @@ public:
      */
     virtual ~PVString() {}
 protected:
-    PVString(ScalarConstPtr & scalar)
+    PVString(ScalarConstPtr const & scalar)
     : PVScalarValue<String>(scalar) {}
 };
 typedef std::tr1::shared_ptr<PVString> PVStringPtr;
@@ -409,7 +409,7 @@ public:
      */
     virtual void setCapacity(std::size_t capacity) = 0;
 protected:
-    PVArray(FieldConstPtr  field);
+    PVArray(FieldConstPtr const & field);
     void setCapacityLength(std::size_t capacity,std::size_t length);
 private:
     class PVArrayPvt * pImpl;
@@ -461,7 +461,7 @@ public:
     ScalarArrayConstPtr getScalarArray() ;
 
 protected:
-    PVScalarArray(ScalarArrayConstPtr scalarArray);
+    PVScalarArray(ScalarArrayConstPtr const & scalarArray);
 private:
     friend class PVDataCreate;
 };
@@ -552,7 +552,7 @@ public:
     virtual vector const & getVector() {return *value;}
     virtual shared_vector const & getSharedVector() {return value;}
 protected:
-    PVStructureArray( StructureArrayConstPtr structureArray);
+    PVStructureArray(StructureArrayConstPtr const & structureArray);
 private:
     StructureArrayConstPtr structureArray;
     shared_vector value;
@@ -597,14 +597,14 @@ public:
      * @param fieldName The name of the field to append.
      * @param pvField The field to append.
      */
-    void appendPVField(String fieldName,PVFieldPtr & pvField);
+    void appendPVField(String fieldName,PVFieldPtr const & pvField);
     /**
      * Append fields to the structure.
      * @param fieldNames The names of the fields to add.
      * @param pvFields The fields to append.
      * @return Pointer to the field or null if field does not exist.
      */
-    void appendPVFields(StringArray & fieldNames,PVFieldPtrArray & pvFields);
+    void appendPVFields(StringArray const & fieldNames,PVFieldPtrArray const & pvFields);
     /**
      * Remove a field from the structure.
      * @param fieldName The name of the field to remove.
@@ -747,13 +747,13 @@ public:
      * Constructor
      * @param structure The introspection interface.
      */
-    PVStructure(StructureConstPtr & structure);
+    PVStructure(StructureConstPtr const & structure);
     /**
      * Constructor
      * @param structure The introspection interface.
      * @param pvFields The array of fields for the structure.
      */
-    PVStructure(StructureConstPtr structure,PVFieldPtrArray & pvFields);
+    PVStructure(StructureConstPtr const & structure,PVFieldPtrArray const & pvFields);
 private:
     PVFieldPtrArray pvFields;
     StructureConstPtr structurePtr;
@@ -811,7 +811,7 @@ public:
     virtual vector const & getVector() = 0;
     virtual shared_vector const & getSharedVector() = 0;
 protected:
-    PVValueArray(ScalarArrayConstPtr scalar)
+    PVValueArray(ScalarArrayConstPtr const & scalar)
     : PVScalarArray(scalar) {}
     friend class PVDataCreate;
 };
@@ -880,67 +880,66 @@ public:
      * @param field The introspection data to be used to create PVField.
      * @return The PVField implementation.
      */
-    PVFieldPtr createPVField(FieldConstPtr & field);
+    PVFieldPtr createPVField(FieldConstPtr const & field);
     /**
      * Create a PVField using given a PVField to clone.
      * This method calls the appropriate createPVScalar, createPVArray, or createPVStructure.
      * @param fieldToClone The field to clone.
      * @return The PVField implementation
      */
-    PVFieldPtr createPVField(PVFieldPtr & fieldToClone);
+    PVFieldPtr createPVField(PVFieldPtr const & fieldToClone);
     /**
      * Create an implementation of a scalar field reusing the Scalar introspection interface.
      * @param scalar The introspection interface.
      * @return The PVScalar implementation.
      */
-    PVScalarPtr createPVScalar(ScalarConstPtr & scalar);
+    PVScalarPtr createPVScalar(ScalarConstPtr const & scalar);
     /**
      * Create an implementation of a scalar field. A Scalar introspection interface is created.
      * @param fieldType The field type.
      * @return The PVScalar implementation.
      */
-    PVScalarPtr createPVScalar(ScalarType  scalarType);
+    PVScalarPtr createPVScalar(ScalarType scalarType);
     /**
      * Create an implementation of a scalar field by cloning an existing PVScalar.
      * The new PVScalar will have the same value and auxInfo as the original.
      * @param scalarToClone The PVScalar to clone.
      * @return The PVScalar implementation.
      */
-    PVScalarPtr createPVScalar(PVScalarPtr &  scalarToClone);
+    PVScalarPtr createPVScalar(PVScalarPtr const & scalarToClone);
     /**
      * Create an implementation of an array field reusing the Array introspection interface.
      * @param array The introspection interface.
      * @return The PVScalarArray implementation.
      */
-    PVScalarArrayPtr createPVScalarArray(ScalarArrayConstPtr & scalarArray);
+    PVScalarArrayPtr createPVScalarArray(ScalarArrayConstPtr const & scalarArray);
     /**
      * Create an implementation for an array field. An Array introspection interface is created.
      * @param parent The parent interface.
      * @param elementType The element type.
      * @return The PVScalarArray implementation.
      */
-    PVScalarArrayPtr createPVScalarArray(
-        ScalarType elementType);
+    PVScalarArrayPtr createPVScalarArray(ScalarType elementType);
     /**
      * Create an implementation of an array field by cloning an existing PVArray.
      * The new PVArray will have the same value and auxInfo as the original.
      * @param arrayToClone The PVScalarArray to clone.
      * @return The PVScalarArray implementation.
      */
-    PVScalarArrayPtr createPVScalarArray(PVScalarArrayPtr &  scalarArrayToClone);
+    PVScalarArrayPtr createPVScalarArray(PVScalarArrayPtr const  & scalarArrayToClone);
     /**
      * Create an implementation of an array with structure elements.
      * @param structureArray The introspection interface.
      * All elements share the same introspection interface.
      * @return The PVStructureArray implementation.
      */
-    PVStructureArrayPtr createPVStructureArray(StructureArrayConstPtr & structureArray);
+    PVStructureArrayPtr createPVStructureArray(StructureArrayConstPtr const & structureArray);
     /**
      * Create implementation for PVStructure.
      * @param structure The introspection interface.
      * @return The PVStructure implementation
      */
-    PVStructurePtr createPVStructure(StructureConstPtr & structure);
+    PVStructurePtr createPVStructure(StructureConstPtr const & structure);
     /**
      * Create implementation for PVStructure.
      * @param fieldNames The field names.
@@ -948,13 +947,13 @@ public:
      * @return The PVStructure implementation
      */
     PVStructurePtr createPVStructure(
-        StringArray & fieldNames,PVFieldPtrArray & pvFields);
+        StringArray const & fieldNames,PVFieldPtrArray const & pvFields);
      /**
       * Create implementation for PVStructure.
       * @param structToClone A structure. Each subfield and any auxInfo is cloned and added to the newly created structure.
       * @return The PVStructure implementation.
       */
-   PVStructurePtr createPVStructure(PVStructurePtr & structToClone);
+   PVStructurePtr createPVStructure(PVStructurePtr const & structToClone);
 private:
    PVDataCreate();
 };
diff --git a/pvDataApp/pv/pvIntrospect.h b/pvDataApp/pv/pvIntrospect.h
index 77b12ae..88535fb 100644
--- a/pvDataApp/pv/pvIntrospect.h
+++ b/pvDataApp/pv/pvIntrospect.h
@@ -353,7 +353,7 @@ protected:
      * Constructor.
      * @param structure The introspection interface for the elements.
      */
-    StructureArray(StructureConstPtr structure);
+    StructureArray(StructureConstPtr const & structure);
     /**
      * Destructor.
      */
@@ -471,7 +471,7 @@ public:
       * @param elementStructure The {@code Structure} for each array element.
       * @return An {@code Array} Interface for the newly created object.
       */
-    StructureArrayConstPtr createStructureArray(StructureConstPtr structure) const;
+    StructureArrayConstPtr createStructureArray(StructureConstPtr const & structure) const;
     /**
      * Create a {@code Structure} field.
      * @param fieldNames The array of {@code fieldNames} for the structure
@@ -489,8 +489,8 @@ public:
      * @return a {@code Structure} interface for the newly created object.
      */
     StructureConstPtr appendField(
-        StructureConstPtr structure,
-        String fieldName, FieldConstPtr field) const;
+        StructureConstPtr const & structure,
+        String fieldName, FieldConstPtr const & field) const;
     /**
      * Append fields to a structure.
      * @param structure The structure to which the fields appended.
@@ -499,7 +499,7 @@ public:
      * @return a {@code Structure} interface for the newly created object.
      */
     StructureConstPtr appendFields(
-        StructureConstPtr structure,
+        StructureConstPtr const & structure,
         StringArray const & fieldNames,
         FieldConstPtrArray const & fields) const;
     /**
diff --git a/pvDataApp/pv/standardField.h b/pvDataApp/pv/standardField.h
index 477c163..990a64e 100644
--- a/pvDataApp/pv/standardField.h
+++ b/pvDataApp/pv/standardField.h
@@ -57,7 +57,7 @@ public:
     ~StandardField();
     StructureConstPtr scalar(ScalarType type,String properties);
     StructureConstPtr scalarArray(ScalarType elementType, String properties);
-    StructureConstPtr structureArray(StructureConstPtr & structure,String properties);
+    StructureConstPtr structureArray(StructureConstPtr const & structure,String properties);
     StructureConstPtr enumerated();
     StructureConstPtr enumerated(String properties);
     StructureConstPtr alarm();
diff --git a/testApp/misc/Makefile b/testApp/misc/Makefile
index 9d66665..d98b7cf 100644
--- a/testApp/misc/Makefile
+++ b/testApp/misc/Makefile
@@ -26,9 +26,9 @@ PROD_HOST += testBaseException
 testBaseException_SRCS += testBaseException.cpp
 testBaseException_LIBS += pvData
 
-#PROD_HOST += testSerialization
-#testSerialization_SRCS += testSerialization.cpp
-#testSerialization_LIBS += pvData Com
+PROD_HOST += testSerialization
+testSerialization_SRCS += testSerialization.cpp
+testSerialization_LIBS += pvData Com
 
 PROD_HOST += testTimeStamp
 testTimeStamp_SRCS += testTimeStamp.cpp
diff --git a/testApp/misc/testSerialization.cpp b/testApp/misc/testSerialization.cpp
index d8515db..f7907a0 100644
--- a/testApp/misc/testSerialization.cpp
+++ b/testApp/misc/testSerialization.cpp
@@ -23,6 +23,8 @@
 #include <pv/CDRMonitor.h>
 #include <pv/convert.h>
 
+#include <pv/standardField.h>
+
 #define BYTE_MAX_VALUE 127
 #define BYTE_MIN_VALUE -128
 #define SHORT_MAX_VALUE 32767
@@ -49,7 +51,7 @@ public:
     virtual void flushSerializeBuffer() {
     }
 
-    virtual void ensureBuffer(int size) {
+    virtual void ensureBuffer(size_t size) {
     }
 
     virtual void alignBuffer(int alignment) {
@@ -71,7 +73,7 @@ public:
 class DeserializableControlImpl : public DeserializableControl,
         public NoDefaultMethods {
 public:
-    virtual void ensureData(int size) {
+    virtual void ensureData(size_t size) {
     }
 
     virtual void alignData(int alignment) {
@@ -90,8 +92,7 @@ public:
     }
 };
 
-
-void serializationTest(PVField* field) {
+void serializationTest(PVFieldPtr const & field) {
     buffer->clear();
 
     // serialize
@@ -100,33 +101,62 @@ void serializationTest(PVField* field) {
     buffer->flip();
 
     // create new instance and deserialize
-    PVField* deserializedField = getPVDataCreate()->createPVField(NULL,
-            field->getField());
+    PVFieldPtr deserializedField = getPVDataCreate()->createPVField(field->getField());
     deserializedField->deserialize(buffer, control);
 
     // must equal
     bool isEqual = getConvert()->equals(*field,*deserializedField);
     assert(isEqual);
-    delete deserializedField; // clean up
+}
+
+void testEquals(std::ostream& ofile) {
+    ofile<<"Testing equals...\n";
+    PVDataCreatePtr factory = getPVDataCreate();
+    assert(factory.get()!=NULL);
+
+	 // be sure all is covered
+	 for (int i = pvBoolean; i < pvString; i++)
+	 {
+		 ScalarType scalarType = static_cast<ScalarType>(i);
+
+		 PVScalarPtr scalar1 = factory->createPVScalar(scalarType);
+		 PVScalarPtr scalar2 = factory->createPVScalar(scalarType);
+		 assert((*scalar1)==(*scalar2));
+
+		 PVScalarArrayPtr array1 = factory->createPVScalarArray(scalarType);
+		 PVScalarArrayPtr array2 = factory->createPVScalarArray(scalarType);
+		 assert((*array1)==(*array2));
+	}
+
+	// and a structure
+    PVStructurePtr structure1 = factory->createPVStructure(getStandardField()->timeStamp());
+    PVStructurePtr structure2 = factory->createPVStructure(getStandardField()->timeStamp());
+	assert((*structure1)==(*structure2));
+
+    // and a structure array
+    PVStructureArrayPtr structureArray1 = factory->createPVStructureArray(getFieldCreate()->createStructureArray(structure1->getStructure()));
+    PVStructureArrayPtr structureArray2 = factory->createPVStructureArray(getFieldCreate()->createStructureArray(structure2->getStructure()));
+	assert((*structureArray1)==(*structureArray2));
+
+    ofile<<"!!!  PASSED\n\n";
 }
 
 void testScalar(std::ostream& ofile) {
     ofile<<"Testing scalars...\n";
-    PVDataCreate* factory = getPVDataCreate();
-    assert(factory!=NULL);
+    PVDataCreatePtr factory = getPVDataCreate();
+    assert(factory.get()!=NULL);
 
     ofile<<"\tPVBoolean\n";
-    PVBoolean* pvBoolean = (PVBoolean*)factory->createPVScalar(NULL,
-            "pvBoolean", epics::pvData::pvBoolean);
+    PVBooleanPtr pvBoolean =
+    		std::tr1::static_pointer_cast<PVBoolean>(factory->createPVScalar(epics::pvData::pvBoolean));
     pvBoolean->put(false);
     serializationTest(pvBoolean);
     pvBoolean->put(true);
     serializationTest(pvBoolean);
-    delete pvBoolean;
 
     ofile<<"\tPVByte\n";
-    PVByte* pvByte = (PVByte*)factory->createPVScalar(NULL, "pvByte",
-            epics::pvData::pvByte);
+    PVBytePtr pvByte =
+    		std::tr1::static_pointer_cast<PVByte>(factory->createPVScalar(epics::pvData::pvByte));
     pvByte->put(0);
     serializationTest(pvByte);
     pvByte->put(12);
@@ -135,11 +165,10 @@ void testScalar(std::ostream& ofile) {
     serializationTest(pvByte);
     pvByte->put(BYTE_MIN_VALUE);
     serializationTest(pvByte);
-    delete pvByte;
 
     ofile<<"\tPVShort\n";
-    PVShort* pvShort = (PVShort*)factory->createPVScalar(NULL, "pvShort",
-            epics::pvData::pvShort);
+    PVShortPtr pvShort =
+    		std::tr1::static_pointer_cast<PVShort>(factory->createPVScalar(epics::pvData::pvShort));
     pvShort->put(0);
     serializationTest(pvShort);
     pvShort->put(123);
@@ -152,11 +181,10 @@ void testScalar(std::ostream& ofile) {
     serializationTest(pvShort);
     pvShort->put(SHORT_MIN_VALUE);
     serializationTest(pvShort);
-    delete pvShort;
 
     ofile<<"\tPVInt\n";
-    PVInt* pvInt = (PVInt*)factory->createPVScalar(NULL, "pvInt",
-            epics::pvData::pvInt);
+    PVIntPtr pvInt =
+    		std::tr1::static_pointer_cast<PVInt>(factory->createPVScalar(epics::pvData::pvInt));
     pvInt->put(0);
     serializationTest(pvInt);
     pvInt->put(123456);
@@ -173,11 +201,10 @@ void testScalar(std::ostream& ofile) {
     serializationTest(pvInt);
     pvInt->put(INT_MIN_VALUE);
     serializationTest(pvInt);
-    delete pvInt;
 
     ofile<<"\tPVLong\n";
-    PVLong* pvLong = (PVLong*)factory->createPVScalar(NULL, "pvLong",
-            epics::pvData::pvLong);
+    PVLongPtr pvLong =
+    		std::tr1::static_pointer_cast<PVLong>(factory->createPVScalar(epics::pvData::pvLong));
     pvLong->put(0);
     serializationTest(pvLong);
     pvLong->put(12345678901LL);
@@ -198,11 +225,10 @@ void testScalar(std::ostream& ofile) {
     serializationTest(pvLong);
     pvLong->put(LONG_MIN_VALUE);
     serializationTest(pvLong);
-    delete pvLong;
 
     ofile<<"\tPVFloat\n";
-    PVFloat* pvFloat = (PVFloat*)factory->createPVScalar(NULL, "pvFloat",
-            epics::pvData::pvFloat);
+    PVFloatPtr pvFloat =
+    		std::tr1::static_pointer_cast<PVFloat>(factory->createPVScalar(epics::pvData::pvFloat));
     pvFloat->put(0);
     serializationTest(pvFloat);
     pvFloat->put(12.345);
@@ -211,11 +237,10 @@ void testScalar(std::ostream& ofile) {
     serializationTest(pvFloat);
     pvFloat->put(FLOAT_MIN_VALUE);
     serializationTest(pvFloat);
-    delete pvFloat;
 
     ofile<<"\tPVDouble\n";
-    PVDouble* pvDouble = (PVDouble*)factory->createPVScalar(NULL, "pvDouble",
-            epics::pvData::pvDouble);
+    PVDoublePtr pvDouble =
+    		std::tr1::static_pointer_cast<PVDouble>(factory->createPVScalar(epics::pvData::pvDouble));
     pvDouble->put(0);
     serializationTest(pvDouble);
     pvDouble->put(12.345);
@@ -224,11 +249,10 @@ void testScalar(std::ostream& ofile) {
     serializationTest(pvDouble);
     pvDouble->put(DOUBLE_MIN_VALUE);
     serializationTest(pvDouble);
-    delete pvDouble;
 
     ofile<<"\tPVString\n";
-    PVString* pvString = (PVString*)factory->createPVScalar(NULL, "pvString",
-            epics::pvData::pvString);
+    PVStringPtr pvString =
+    		std::tr1::static_pointer_cast<PVString>(factory->createPVScalar(epics::pvData::pvString));
     pvString->put("");
     serializationTest(pvString);
     pvString->put("s");
@@ -244,7 +268,7 @@ void testScalar(std::ostream& ofile) {
     pvString->put(String(10000, 'a'));
     serializationTest(pvString);
 
-    delete pvString;
+    // TODO unsigned test
 
     ofile<<"!!!  PASSED\n\n";
 }
@@ -252,93 +276,86 @@ void testScalar(std::ostream& ofile) {
 void testArray(std::ostream& ofile) {
     ofile<<"Testing arrays...\n";
 
-    PVDataCreate* factory = getPVDataCreate();
-    assert(factory!=NULL);
+    PVDataCreatePtr factory = getPVDataCreate();
+    assert(factory.get()!=NULL);
 
     ofile<<"\tPVBooleanArray\n";
     bool boolEmpty[] = { false };
     bool bv[] = { false, true, false, true, true };
-    PVBooleanArray* pvBoolean = (PVBooleanArray*)factory->createPVScalarArray(
-            NULL, "pvBooleanArray", epics::pvData::pvBoolean);
-    pvBoolean->put(0, 0, boolEmpty, 0);
+    PVBooleanArrayPtr pvBoolean =
+    		std::tr1::static_pointer_cast<PVBooleanArray>(factory->createPVScalarArray(epics::pvData::pvBoolean));
+//TODO    pvBoolean->put(0, 0, boolEmpty, 0);
     serializationTest(pvBoolean);
-    pvBoolean->put(0, 5, bv, 0);
+//TODO    pvBoolean->put(0, 5, bv, 0);
     serializationTest(pvBoolean);
-    delete pvBoolean;
 
     ofile<<"\tPVByteArray\n";
     int8 byteEmpty[] = { 0 };
     int8 byv[] = { 0, 1, 2, -1, BYTE_MAX_VALUE, BYTE_MAX_VALUE-1,
             BYTE_MIN_VALUE+1, BYTE_MIN_VALUE };
-    PVByteArray* pvByte = (PVByteArray*)factory->createPVScalarArray(NULL,
-            "pvByteArray", epics::pvData::pvByte);
+    PVByteArrayPtr pvByte =
+    		std::tr1::static_pointer_cast<PVByteArray>(factory->createPVScalarArray(epics::pvData::pvByte));
     pvByte->put(0, 0, byteEmpty, 0);
     serializationTest(pvByte);
     pvByte->put(0, 8, byv, 0);
     serializationTest(pvByte);
-    delete pvByte;
 
     ofile<<"\tPVShortArray\n";
     int16 shortEmpty[] = { 0 };
     int16 sv[] = { 0, 1, 2, -1, SHORT_MAX_VALUE, SHORT_MAX_VALUE-1,
             SHORT_MIN_VALUE+1, SHORT_MIN_VALUE };
-    PVShortArray* pvShort = (PVShortArray*)factory->createPVScalarArray(NULL,
-            "pvShortArray", epics::pvData::pvShort);
+    PVShortArrayPtr pvShort =
+    		std::tr1::static_pointer_cast<PVShortArray>(factory->createPVScalarArray(epics::pvData::pvShort));
     pvShort->put(0, 0, shortEmpty, 0);
     serializationTest(pvShort);
     pvShort->put(0, 8, sv, 0);
     serializationTest(pvShort);
-    delete pvShort;
 
     ofile<<"\tPVIntArray\n";
     int32 intEmpty[] = { 0 };
     int32 iv[] = { 0, 1, 2, -1, INT_MAX_VALUE, INT_MAX_VALUE-1,
             INT_MIN_VALUE+1, INT_MIN_VALUE };
-    PVIntArray* pvInt = (PVIntArray*)factory->createPVScalarArray(NULL,
-            "pvIntArray", epics::pvData::pvInt);
+    PVIntArrayPtr pvInt =
+    		std::tr1::static_pointer_cast<PVIntArray>(factory->createPVScalarArray(epics::pvData::pvInt));
     pvInt->put(0, 0, intEmpty, 0);
     serializationTest(pvInt);
     pvInt->put(0, 8, iv, 0);
     serializationTest(pvInt);
-    delete pvInt;
 
     ofile<<"\tPVLongArray\n";
     int64 longEmpty[] = { 0 };
     int64 lv[] = { 0, 1, 2, -1, LONG_MAX_VALUE, LONG_MAX_VALUE-1,
             LONG_MIN_VALUE+1, LONG_MIN_VALUE };
-    PVLongArray* pvLong = (PVLongArray*)factory->createPVScalarArray(NULL,
-            "pvLongArray", epics::pvData::pvLong);
+    PVLongArrayPtr pvLong =
+    		std::tr1::static_pointer_cast<PVLongArray>(factory->createPVScalarArray(epics::pvData::pvLong));
     pvLong->put(0, 0, longEmpty, 0);
     serializationTest(pvLong);
     pvLong->put(0, 8, lv, 0);
     serializationTest(pvLong);
-    delete pvLong;
 
     ofile<<"\tPVFloatArray\n";
     float floatEmpty[] = { (float)0.0 };
     float fv[] = { (float)0.0, (float)1.1, (float)2.3, (float)-1.4,
             FLOAT_MAX_VALUE, FLOAT_MAX_VALUE-(float)123456.789, FLOAT_MIN_VALUE
                     +(float)1.1, FLOAT_MIN_VALUE };
-    PVFloatArray* pvFloat = (PVFloatArray*)factory->createPVScalarArray(NULL,
-            "pvFloatArray", epics::pvData::pvFloat);
+    PVFloatArrayPtr pvFloat =
+    		std::tr1::static_pointer_cast<PVFloatArray>(factory->createPVScalarArray(epics::pvData::pvFloat));
     pvFloat->put(0, 0, floatEmpty, 0);
     serializationTest(pvFloat);
     pvFloat->put(0, 8, fv, 0);
     serializationTest(pvFloat);
-    delete pvFloat;
 
     ofile<<"\tPVDoubleArray\n";
     double doubleEmpty[] = { (double)0.0 };
     double dv[] = { (double)0.0, (double)1.1, (double)2.3, (double)-1.4,
             DOUBLE_MAX_VALUE, DOUBLE_MAX_VALUE-(double)123456.789,
             DOUBLE_MIN_VALUE+(double)1.1, DOUBLE_MIN_VALUE };
-    PVDoubleArray* pvDouble = (PVDoubleArray*)factory->createPVScalarArray(
-            NULL, "pvDoubleArray", epics::pvData::pvDouble);
+    PVDoubleArrayPtr pvDouble =
+    		std::tr1::static_pointer_cast<PVDoubleArray>(factory->createPVScalarArray(epics::pvData::pvDouble));
     pvDouble->put(0, 0, doubleEmpty, 0);
     serializationTest(pvDouble);
     pvDouble->put(0, 8, dv, 0);
     serializationTest(pvDouble);
-    delete pvDouble;
 
     ofile<<"\tPVStringArray\n";
     String stringEmpty[] = { "" };
@@ -353,295 +370,122 @@ void testArray(std::ostream& ofile) {
                             "smile",
                             "this is a little longer string... maybe a little but longer... this makes test better",
                             String(10000, 'b') };
-    PVStringArray* pvString = (PVStringArray*)factory->createPVScalarArray(
-            NULL, "pvStringArray", epics::pvData::pvString);
+    PVStringArrayPtr pvString =
+    		std::tr1::static_pointer_cast<PVStringArray>(factory->createPVScalarArray(epics::pvData::pvString));
     pvString->put(0, 0, stringEmpty, 0);
     serializationTest(pvString);
     pvString->put(0, 8, strv, 0);
     serializationTest(pvString);
-    delete pvString;
 
     ofile<<"!!!  PASSED\n\n";
 }
 
-void testScalarEquals(std::ostream& ofile) {
-    ofile<<"Testing scalar equals...\n";
-    PVDataCreate* factory = getPVDataCreate();
-    assert(factory!=NULL);
+void testNonInitialized(std::ostream& ofile) {
+    ofile<<"Testing non-initialized...\n";
+    PVDataCreatePtr factory = getPVDataCreate();
+    assert(factory.get()!=NULL);
 
-    PVScalar *scalar1, *scalar2;
+	 // be sure all is covered
+	 for (int i = pvBoolean; i < pvString; i++)
+	 {
+		 ScalarType scalarType = static_cast<ScalarType>(i);
 
-    scalar1 = factory->createPVScalar(NULL, "pvBoolean",
-            epics::pvData::pvBoolean);
-    scalar2 = factory->createPVScalar(NULL, "pvBoolean",
-            epics::pvData::pvBoolean);
-    assert((*scalar1)==(*scalar2));
-    delete scalar1;
-    delete scalar2;
+		 PVScalarPtr scalar = factory->createPVScalar(scalarType);
+		 serializationTest(scalar);
 
-    scalar1 = factory->createPVScalar(NULL, "pvByte", epics::pvData::pvByte);
-    scalar2 = factory->createPVScalar(NULL, "pvByte", epics::pvData::pvByte);
-    assert((*scalar1)==(*scalar2));
-    delete scalar1;
-    delete scalar2;
+		 PVScalarArrayPtr array = factory->createPVScalarArray(scalarType);
+		 serializationTest(array);
+	}
 
-    scalar1 = factory->createPVScalar(NULL, "pvShort", epics::pvData::pvShort);
-    scalar2 = factory->createPVScalar(NULL, "pvShort", epics::pvData::pvShort);
-    assert((*scalar1)==(*scalar2));
-    delete scalar1;
-    delete scalar2;
+	// and a structure
+	PVStructurePtr structure = factory->createPVStructure(getStandardField()->timeStamp());
+	serializationTest(structure);
 
-    scalar1 = factory->createPVScalar(NULL, "pvInt", epics::pvData::pvInt);
-    scalar2 = factory->createPVScalar(NULL, "pvInt", epics::pvData::pvInt);
-    assert((*scalar1)==(*scalar2));
-    delete scalar1;
-    delete scalar2;
+	// and a structure array
+	PVStructureArrayPtr structureArray = factory->createPVStructureArray(getFieldCreate()->createStructureArray(structure->getStructure()));
+	serializationTest(structureArray);
 
-    scalar1 = factory->createPVScalar(NULL, "pvLong", epics::pvData::pvLong);
-    scalar2 = factory->createPVScalar(NULL, "pvLong", epics::pvData::pvLong);
-    assert((*scalar1)==(*scalar2));
-    delete scalar1;
-    delete scalar2;
-
-    scalar1 = factory->createPVScalar(NULL, "pvFloat", epics::pvData::pvFloat);
-    scalar2 = factory->createPVScalar(NULL, "pvFloat", epics::pvData::pvFloat);
-    assert((*scalar1)==(*scalar2));
-    delete scalar1;
-    delete scalar2;
-
-    scalar1
-            = factory->createPVScalar(NULL, "pvDouble", epics::pvData::pvDouble);
-    scalar2
-            = factory->createPVScalar(NULL, "pvDouble", epics::pvData::pvDouble);
-    assert((*scalar1)==(*scalar2));
-    delete scalar1;
-    delete scalar2;
-
-    scalar1
-            = factory->createPVScalar(NULL, "pvString", epics::pvData::pvString);
-    scalar2
-            = factory->createPVScalar(NULL, "pvString", epics::pvData::pvString);
-    assert((*scalar1)==(*scalar2));
-    delete scalar1;
-    delete scalar2;
-
-    FieldCreate* fieldCreate = getFieldCreate();
-    FieldConstPtrArray fields = new FieldConstPtr[2];
-    fields[0] = fieldCreate->createScalar("secondsSinceEpoch",
-            epics::pvData::pvLong);
-    fields[1] = fieldCreate->createScalar("nanoSeconds", epics::pvData::pvInt);
-    StructureConstPtr structure = fieldCreate->createStructure("timeStamp", 2,
-            fields);
-
-    PVStructure* pvStruct1 = factory->createPVStructure(NULL, structure);
-    PVStructure* pvStruct2 = factory->createPVStructure(NULL, structure);
-    assert((*pvStruct1)==(*pvStruct2));
-    delete pvStruct2;
-    delete pvStruct1;
-    // 'structure' and 'fields' are deleted implicitly
-
-    ofile<<"!!!  PASSED\n\n";
-}
-
-void testScalarNonInitialized(std::ostream& ofile) {
-    ofile<<"Testing scalar non-initialized...\n";
-    PVDataCreate* factory = getPVDataCreate();
-    assert(factory!=NULL);
-
-    PVScalar* scalar;
-
-    scalar = factory->createPVScalar(NULL, "pvBoolean",
-            epics::pvData::pvBoolean);
-    serializationTest(scalar);
-    delete scalar;
-
-    scalar = factory->createPVScalar(NULL, "pvByte", epics::pvData::pvByte);
-    serializationTest(scalar);
-    delete scalar;
-
-    scalar = factory->createPVScalar(NULL, "pvShort", epics::pvData::pvShort);
-    serializationTest(scalar);
-    delete scalar;
-
-    scalar = factory->createPVScalar(NULL, "pvInt", epics::pvData::pvInt);
-    serializationTest(scalar);
-    delete scalar;
-
-    scalar = factory->createPVScalar(NULL, "pvLong", epics::pvData::pvLong);
-    serializationTest(scalar);
-    delete scalar;
-
-    scalar = factory->createPVScalar(NULL, "pvFloat", epics::pvData::pvFloat);
-    serializationTest(scalar);
-    delete scalar;
-
-    scalar = factory->createPVScalar(NULL, "pvDouble", epics::pvData::pvDouble);
-    serializationTest(scalar);
-    delete scalar;
-
-    scalar = factory->createPVScalar(NULL, "pvString", epics::pvData::pvString);
-    serializationTest(scalar);
-    delete scalar;
-
-    FieldCreate* fieldCreate = getFieldCreate();
-    FieldConstPtrArray fields = new FieldConstPtr[2];
-    fields[0] = fieldCreate->createScalar("secondsSinceEpoch",
-            epics::pvData::pvLong);
-    fields[1] = fieldCreate->createScalar("nanoSeconds", epics::pvData::pvInt);
-    StructureConstPtr structure = fieldCreate->createStructure("timeStamp", 2,
-            fields);
-
-    PVStructure* pvStruct = factory->createPVStructure(NULL, structure);
-    serializationTest(pvStruct);
-    delete pvStruct; // 'structure' and 'fields' are deleted implicitly
-
-    ofile<<"!!!  PASSED\n\n";
-}
-
-void testArrayNonInitialized(std::ostream& ofile) {
-    ofile<<"Testing array non-initialized...\n";
-    PVDataCreate* factory = getPVDataCreate();
-    assert(factory!=NULL);
-
-    PVArray* array;
-
-    array = factory->createPVScalarArray(NULL, "pvBooleanArray",
-            epics::pvData::pvBoolean);
-    serializationTest(array);
-    delete array;
-
-    array = factory->createPVScalarArray(NULL, "pvByteArray",
-            epics::pvData::pvByte);
-    serializationTest(array);
-    delete array;
-
-    array = factory->createPVScalarArray(NULL, "pvShortArray",
-            epics::pvData::pvShort);
-    serializationTest(array);
-    delete array;
-
-    array = factory->createPVScalarArray(NULL, "pvIntArray",
-            epics::pvData::pvInt);
-    serializationTest(array);
-    delete array;
-
-    array = factory->createPVScalarArray(NULL, "pvLongArray",
-            epics::pvData::pvLong);
-    serializationTest(array);
-    delete array;
-
-    array = factory->createPVScalarArray(NULL, "pvFloatArray",
-            epics::pvData::pvFloat);
-    serializationTest(array);
-    delete array;
-
-    array = factory->createPVScalarArray(NULL, "pvDoubleArray",
-            epics::pvData::pvDouble);
-    serializationTest(array);
-    delete array;
-
-    array = factory->createPVScalarArray(NULL, "pvStringArray",
-            epics::pvData::pvString);
-    serializationTest(array);
-    delete array;
-
-    FieldCreate* fieldCreate = getFieldCreate();
-    FieldConstPtrArray fields = new FieldConstPtr[2];
-    fields[0] = fieldCreate->createScalar("secondsSinceEpoch",
-            epics::pvData::pvLong);
-    fields[1] = fieldCreate->createScalar("nanoSeconds", epics::pvData::pvInt);
-    StructureConstPtr structure = fieldCreate->createStructure("timeStamp", 2,
-            fields);
-
-    StructureArrayConstPtr structureArray = fieldCreate->createStructureArray(
-            "timeStampArray", structure);
-    PVStructureArray* pvStructArray = factory->createPVStructureArray(NULL,
-            structureArray);
-    serializationTest(pvStructArray);
-    delete pvStructArray; // also deletes 'structureArray',
-    //'structureArray' also deletes 'structure'
-    //'structure' also deletes 'fields'
-
-    ofile<<"!!!  PASSED\n\n";
+	ofile<<"!!!  PASSED\n\n";
 }
 
 void testStructure(std::ostream& ofile) {
     ofile<<"Testing structure...\n";
 
-    FieldCreate* fieldCreate = getFieldCreate();
-    PVDataCreate* pvDataCreate = getPVDataCreate();
-    assert(fieldCreate!=NULL);
-    assert(pvDataCreate!=NULL);
+    PVDataCreatePtr factory = getPVDataCreate();
+    assert(factory.get()!=NULL);
 
     ofile<<"\tSimple structure serialization\n";
-    FieldConstPtrArray fields = new FieldConstPtr[2];
-    fields[0] = fieldCreate->createScalar("secondsSinceEpoch",
-            epics::pvData::pvLong);
-    fields[1] = fieldCreate->createScalar("nanoSeconds", epics::pvData::pvInt);
-    PVStructure* pvStructure = pvDataCreate->createPVStructure(NULL,
-            "timestamp", 2, fields);
-    pvStructure->getLongField(fields[0]->getFieldName())->put(123);
-    pvStructure->getIntField(fields[1]->getFieldName())->put(456);
+	PVStructurePtr pvStructure = factory->createPVStructure(getStandardField()->timeStamp());
+    pvStructure->getLongField("secondsPastEpoch")->put(123);
+    pvStructure->getIntField("nanoSeconds")->put(456);
+    pvStructure->getIntField("userTag")->put(789);
 
     serializationTest(pvStructure);
-    //serializationTest(pvStructure->getStructure());
-    delete pvStructure;
 
     ofile<<"\tComplex structure serialization\n";
-    // and more complex :)
-    FieldConstPtrArray fields2 = new FieldConstPtr[4];
-    fields2[0] = fieldCreate->createScalar("longVal", epics::pvData::pvLong);
-    fields2[1] = fieldCreate->createScalar("intVal", epics::pvData::pvInt);
-    fields2[2] = fieldCreate->createScalarArray("values", epics::pvData::pvDouble);
-    FieldConstPtrArray fields3 = new FieldConstPtr[2];
-    fields3[0] = fieldCreate->createScalar("secondsSinceEpoch", epics::pvData::pvLong);
-    fields3[1] = fieldCreate->createScalar("nanoSeconds", epics::pvData::pvInt);
-    fields2[3] = fieldCreate->createStructure("timeStamp", 2, fields3);
-    PVStructure* pvStructure2 = pvDataCreate->createPVStructure(NULL,
-            "complexStructure", 4, fields2);
-    pvStructure2->getLongField(fields2[0]->getFieldName())->put(1234);
-    pvStructure2->getIntField(fields2[1]->getFieldName())->put(4567);
-    PVDoubleArray* da = (PVDoubleArray*)pvStructure2->getScalarArrayField(
-            fields2[2]->getFieldName(), epics::pvData::pvDouble);
-    double dd[] = { 1.2, 3.4, 4.5 };
-    da->put(0, 3, dd, 0);
-
-    PVStructure* ps = pvStructure2->getStructureField(
-            fields2[3]->getFieldName());
-    ps->getLongField(fields3[0]->getFieldName())->put(789);
-    ps->getIntField(fields3[1]->getFieldName())->put(1011);
-
-    serializationTest(pvStructure2);
-    //serializationTest(pvStructure2->getStructure());
-    delete pvStructure2;
-
+	pvStructure = factory->createPVStructure(
+			getStandardField()->structureArray(
+					getStandardField()->timeStamp(), "alarm,control,display,timeStamp")
+			);
+	// TODO fill with data
+    serializationTest(pvStructure);
 
     ofile<<"!!!  PASSED\n\n";
 }
 
-/*
- void testIntrospectionSerialization() {
- cout<<"Testing introspection serialization...\n";
- FieldCreate* factory = getFieldCreate();
- assert(factory!=NULL);
+void serializatioTest(FieldConstPtr const & field)
+{
+	buffer->clear();
 
- ScalarConstPtr scalar = factory->createScalar("scalar", epics::pvData::pvDouble);
- serializatioTest(scalar);
- delete scalar;
+	// serialize
+	field->serialize(buffer, flusher);
 
- ScalarArrayConstPtr array = factory->createScalarArray("array", epics::pvData::pvDouble);
- serializatioTest(array);
- delete array;
+	// deserialize
+	buffer->flip();
 
- cout<<"!!!  PASSED\n\n";
+	FieldConstPtr deserializedField = getFieldCreate()->deserialize(buffer, control);
+
+	// must equal
+	bool isEqual = *field == *deserializedField;
+	assert(isEqual);
+	//assertEquals("field " + field.toString() + " serialization broken", field, deserializedField);
+}
+
+void testIntrospectionSerialization(std::ostream& ofile)
+{
+	 ofile<<"Testing introspection serialization...\n";
+
+	 FieldCreatePtr factory = getFieldCreate();
+	 assert(factory.get()!=NULL);
+
+	 // be sure all is covered
+	 for (int i = pvBoolean; i < pvString; i++)
+	 {
+		 ScalarType scalarType = static_cast<ScalarType>(i);
+
+		 ScalarConstPtr scalar = factory->createScalar(scalarType);
+		 serializatioTest(scalar);
+
+		 ScalarArrayConstPtr array = factory->createScalarArray(scalarType);
+		 serializatioTest(array);
+	}
+
+     // and a structure
+     StructureConstPtr structure = getStandardField()->timeStamp();
+     serializatioTest(structure);
+
+     // and a structure array
+     StructureArrayConstPtr structureArray = factory->createStructureArray(structure);
+     serializatioTest(structureArray);
+
+	 ofile<<"!!!  PASSED\n\n";
  }
- */
 
 void testStringCopy(std::ostream& ofile) {
     String s1 = "abc";
     String s2 = s1;
     if (s1.c_str() != s2.c_str())
-        ofile << "\n!!! implementation of epics::pvData::String assigment operator does not share content !!!\n\n";
+        ofile << "\n!!! implementation of epics::pvData::String assignment operator does not share content !!!\n\n";
 }
 
 int main(int argc, char *argv[]) {
@@ -661,13 +505,15 @@ int main(int argc, char *argv[]) {
     buffer = new ByteBuffer(1<<16);
 
     testStringCopy(*out);
-    testScalarEquals(*out);
+
+    testIntrospectionSerialization(*out);
+    testEquals(*out);
+    testNonInitialized(*out);
+
     testScalar(*out);
     testArray(*out);
-    testScalarNonInitialized(*out);
-    testArrayNonInitialized(*out);
     testStructure(*out);
-    //testIntrospectionSerialization();
+
 
     delete buffer;
     delete control;