[558933] add multibit partial access

within BYTE single BOOL-Elements can be adressed with .X<index>() within WORD single BOOL-Elements can be adressed with .X<index>() within WORD single BYTE-Elements can be adressed with .B<index>() within DWORD single BOOL-Elements can be adressed with .X<index>() within DWORD single BYTE-Elements can be adressed with .B<index>() within DWORD single WORD-Elements can be adressed with .W<index>() within LWORD single BOOL-Elements can be adressed with .X<index>() within LWORD single BYTE-Elements can be adressed with .B<index>() within LWORD single WORD-Elements can be adressed with .W<index>() within LWORD single DWORD-Elements can be adressed with .D<index>() Bug: https://bugs.eclipse.org/bugs/show_bug.cgi?id=558933 Signed-off-by: Ernst Blecha <ernst.blecha@jku.at> Change-Id: I5627a30803c644161cd4819aa248b5e236cf12d4
author: Ernst Blecha 2020-01-08 17:18:02 +0000
committer: Ernst Blecha 2020-01-27 15:51:50 +0000
commit: 5bb1cfed4d722ad245deca0d83fca88f024c93b4 (patch)
tree: 4e88cb6176d065eb199176143329ac87a324b852
parent: f435b4e3b34e2a240ef48e52f2c06cc890a5204c (diff)
download: org.eclipse.4diac.forte-5bb1cfed4d722ad245deca0d83fca88f024c93b4.tar.gz
org.eclipse.4diac.forte-5bb1cfed4d722ad245deca0d83fca88f024c93b4.tar.xz
org.eclipse.4diac.forte-5bb1cfed4d722ad245deca0d83fca88f024c93b4.zip
12 files changed, 2835 insertions, 3 deletions
diff --git a/src/core/datatypes/forte_any_bit.h b/src/core/datatypes/forte_any_bit.h
index 61d350fe9..22a8ba597 100644
--- a/src/core/datatypes/forte_any_bit.h
+++ b/src/core/datatypes/forte_any_bit.h
@@ -1,6 +1,6 @@
 /*******************************************************************************
  * Copyright (c) 2005 - 2013 Profactor GmbH, ACIN
- *
+ *               2020 Johannes Kepler University Linz
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License 2.0 which is available at
  * http://www.eclipse.org/legal/epl-2.0.
@@ -11,11 +11,13 @@
  *    Thomas Strasser, Ingomar Müller, Alois Zoitl, Monika Wenger,
  *    Martin Melik Merkumians
  *      - initial implementation and rework communication infrastructure
+ *    Ernst Blecha - add multibit partial access
   *******************************************************************************/
 #ifndef _ANY_BIT_H_
 #define _ANY_BIT_H_
 
 #include "forte_any_elementary.h"
+#include <limits>
 
 /*!\ingroup COREDTS IIEC_ANY_BIT represents any bit data types according to IEC 61131.
  */
@@ -30,6 +32,196 @@ class CIEC_ANY_BIT : public CIEC_ANY_ELEMENTARY{
     CIEC_ANY_BIT() :
         CIEC_ANY_ELEMENTARY(){
     }
+
+    /*! \brief Set method for data type member value
+     *
+     *  The data type value is set using th setLargestUInt method;
+     *  This method needs to be derived in case of chaining multiple access elements after one another (e.g. [LWORD].D<1>().W<1>().B<1>().X<1>()).
+     *
+     */
+    virtual void setValuePartial(TLargestUIntValueType paValue) {
+      this->setLargestUInt(paValue);
+    }
+
+    template <class TBase, class TObject, size_t TIndex>
+    class PARTIAL_ACCESS : public TBase{
+    private:
+      typedef typename TBase::TValueType TBaseType; // Shortcut for the value type used by the access object
+                                                    // evaluates to TForteByte, TForteWord or TForteDWord
+      typedef typename TObject::TValueType TObjectType; // Shortcut for the value type used by the data-object
+                                                        // evaluates to TForteWord, TForteDWord or TForteLWord
+      static const size_t length = std::numeric_limits<TObjectType>::digits/std::numeric_limits<TBaseType>::digits; // amount of accessible elements
+      union TFortePartial {                    // Split the data value into multiple indexable elements
+        TLargestUIntValueType mLargestUInt;
+        TBaseType mData[length];
+      };
+
+      TObject& dataObject; // The referenced object which data is pulled from
+      const size_t index;  // Index value for accessing the split elements
+
+      /*! \brief Method for handling endianess conversion
+       *
+       *  On little endian systems the index value can directly be returned.
+       *  On big endian systems the order of bytes has to be flipped.
+       *
+       */
+      static constexpr size_t endianiseIndex(const size_t paIndex){
+#ifdef FORTE_BIG_ENDIAN
+        return length-1-paIndex;
+#else //#ifdef FORTE_BIG_ENDIAN
+        return paIndex;
+#ifndef FORTE_LITTLE_ENDIAN
+#error Endianess not defined
+#endif //#ifndef FORTE_LITTLE_ENDIAN
+#endif //#ifdef FORTE_BIG_ENDIAN
+      }
+
+      /*! \brief Method to read the partial element form the referenced object
+       *
+       *  This is a static method since it is used during object construction
+       *
+       */
+      static TBaseType getPartial(TObject &src, const size_t index){
+        TFortePartial temp;
+        temp.mLargestUInt = src.getLargestUInt();
+        return temp.mData[index];
+      }
+
+      /*! \brief Method for internally setting the objects data type member value
+       *
+       * Reads the current value from the referenced object, changes the indexed element and writes it back to the referenced object.
+       * Also sets the data type member value of this object in order to allow object reuse by the compiler
+       *
+       */
+      PARTIAL_ACCESS<TBase, TObject, TIndex>& setPartial(TBaseType paValue){
+        TFortePartial temp;
+        temp.mLargestUInt = dataObject.getLargestUInt();
+        temp.mData[index] = paValue;
+        dataObject.setValuePartial(static_cast<TLargestUIntValueType>(temp.mLargestUInt));
+        TBase::setLargestUInt(paValue); // Store to the temporary object. Otherwise this might behave incorrect on object reuse.
+        return *this;
+      }
+
+      public:
+        /*! \brief Constructor: Setup of byte/word/dword-access-object
+         *
+         *  The data member value is set based on the value of paSrc and the selected index.
+         *  Out of Bounds checking is implemented on the index value as a static check; The index therefore has to be known at compile time.
+         *  The index is stored after correction for endianess.
+         */
+        explicit PARTIAL_ACCESS(TObject &paSrc) :
+          TBase(getPartial(paSrc, TIndex)), dataObject(paSrc), index(endianiseIndex(TIndex)){
+          static_assert(TIndex < length, "Index for partial access out of bounds.");
+        };
+
+        /*! \brief Operator: setValue method that handles parts correctly (As long as its not a complex data structure - e.g. CIEC_STRING will not work!).
+         *
+         */
+        virtual void setValue(const CIEC_ANY &pa_roValue){
+          TBase::setValue(pa_roValue); //Extract the value using the base class' setValue method
+          setPartial(static_cast<TBaseType>(this->getLargestUInt()));
+        }
+
+        /*! \brief Operator: Assignment operator with elementary type as its input
+         *
+         */
+        PARTIAL_ACCESS<TBase, TObject, TIndex>& operator =(TBaseType paValue){
+          return setPartial(paValue); // No need for conversion, TBaseType can be directly assigned
+        }
+
+        /*! \brief Operator: Assignment operator with CIEC_XXXX as its input
+         *
+         */
+        PARTIAL_ACCESS<TBase, TObject, TIndex>& operator =(const TBase &paValue){
+          return setPartial(paValue); // This does conversion from TBase to TBaseType implicitly
+        }
+
+      protected:
+        /*! \brief Set method for data type member value
+         *
+         *  The data type value is set through the objects setPartial method;
+         *  This derived method handles chaining access elements.
+         *
+         */
+        virtual void setValuePartial(TLargestUIntValueType paValue) {
+          setPartial(static_cast<TBaseType>(paValue));
+        }
+
+    };
+
+    template <class TBOOL, class TObject, size_t TIndex> // the template parameter TBOOL allows use of CIEC_BOOL "before" it is fully evaluated
+    class PARTIAL_ACCESS_BIT : public TBOOL{
+    private:
+      typedef typename TObject::TValueType TObjectType; // Shortcut for the value type used by the data-object
+                                                        // evaluates to TForteByte, TForteWord, TForteDWord or TForteLWord
+      static const size_t length = std::numeric_limits<TObjectType>::digits; // amount of accessible bits
+
+      TObject& dataObject; // The referenced object which data is pulled from
+
+      /*! \brief Method to read the partial element form the referenced object
+       *
+       *  This is a static method since it is used during object construction
+       *
+       */
+      static bool getPartial(TObject &src, const size_t index){
+        return ( 0 != (src.getLargestUInt() & ((TLargestUIntValueType)1 << index)));
+      }
+
+      /*! \brief Method for internally setting the objects data type member value
+       *
+       * Reads the current value from the referenced object, changes the indexed element and writes it back to the referenced object.
+       * Also sets the data type member value of this object in order to allow object reuse by the compiler
+       *
+       */
+      PARTIAL_ACCESS_BIT<TBOOL, TObject, TIndex>& setPartial(bool paValue) {
+        TLargestUIntValueType temp = dataObject.getLargestUInt();
+        if(paValue) {
+          temp |=  ((TLargestUIntValueType)1 << TIndex);
+        } else {
+          temp &= ~((TLargestUIntValueType)1 << TIndex);
+        }
+        dataObject.setValuePartial(static_cast<TLargestUIntValueType>(temp));
+        this->setLargestUInt(false != paValue); // Store to the temporary object. Otherwise this might behave incorrect on object reuse.
+        return *this;
+      }
+
+      public:
+        /*! \brief Constructor: Setup of bit-access-object
+         *
+         *  The data member value is set based on the value of paSrc and the selected index.
+         *  Out of Bounds checking is implemented on the index value as a static check; The index therefore has to be known at compile time.
+         *  As bit-alignment is not affected by endianess the index can directly be used without conversion.
+         *
+         */
+        explicit PARTIAL_ACCESS_BIT(TObject &paSrc) :
+          TBOOL(getPartial(paSrc, TIndex)), dataObject(paSrc){
+          static_assert(TIndex < length, "Index for partial access out of bounds.");
+        }
+
+        /*! \brief Operator: setValue method that handles parts correctly (As long as its not a complex data structure - e.g. CIEC_STRING will not work!).
+         *
+         */
+        virtual void setValue(const CIEC_ANY &pa_roValue){
+          TBOOL::setValue(pa_roValue);
+          setPartial(static_cast<bool>(false != this->getLargestUInt()));
+        }
+
+        /*! \brief Operator: Assignment operator with elementary bool as its input
+         *
+         */
+        PARTIAL_ACCESS_BIT<TBOOL, TObject, TIndex>& operator =(bool paValue){
+          return setPartial(paValue); // No need for conversion, TBaseType can be directly assigned
+        }
+
+        /*! \brief Operator: Assignment operator with CIEC_BOOL as its input
+         *
+         */
+        PARTIAL_ACCESS_BIT<TBOOL, TObject, TIndex>& operator =(const TBOOL &paValue){
+          return setPartial(paValue); // This does conversion from CIEC_BOOL to bool implicitly
+        }
+
+    };
+
 };
 
 #endif /*_MANY_BIT_H_*/
diff --git a/src/core/datatypes/forte_byte.h b/src/core/datatypes/forte_byte.h
index 963eb0234..47ef0a49b 100644
--- a/src/core/datatypes/forte_byte.h
+++ b/src/core/datatypes/forte_byte.h
@@ -1,5 +1,6 @@
 /*******************************************************************************
  * Copyright (c) 2005 - 2013 Profactor GmbH, ACIN
+ *               2020 Johannes Kepler University Linz
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License 2.0 which is available at
  * http://www.eclipse.org/legal/epl-2.0.
@@ -10,11 +11,13 @@
  *    Thomas Strasser, Ingomar Müller, Alois Zoitl, Gerhard Ebenhofer,
  *    Ingo Hegny, Martin Melik-Merkumians, Monika Wenger
  *      - initial implementation and rework communication infrastructure
+ *    Ernst Blecha - add multibit partial access
  *******************************************************************************/
 #ifndef _FORTE_BYTE_H_
 #define _FORTE_BYTE_H_
 
 #include "forte_any_bit.h"
+#include "forte_bool.h"
 #include <limits>
 
 /*!\ingroup COREDTS CIEC_BYTE represents the byte data type according to IEC 61131.
@@ -73,6 +76,13 @@ class CIEC_BYTE : public CIEC_ANY_BIT{
     virtual EDataTypeID getDataTypeID() const{
       return CIEC_ANY::e_BYTE;
     }
+
+    /*! \brief Access a single bit within a CIEC_BYTE (e.g. [BYTE].X<1>())
+     *
+     */
+    template <size_t paIndex> PARTIAL_ACCESS_BIT<CIEC_BOOL, CIEC_BYTE, paIndex> X(){
+      return PARTIAL_ACCESS_BIT<CIEC_BOOL, CIEC_BYTE, paIndex>(*this);
+    }
 };
 
 #endif /*_FORTE_BYTE_H_*/
diff --git a/src/core/datatypes/forte_dword.h b/src/core/datatypes/forte_dword.h
index 6a2895c62..a9031281b 100644
--- a/src/core/datatypes/forte_dword.h
+++ b/src/core/datatypes/forte_dword.h
@@ -1,5 +1,6 @@
 /*******************************************************************************
  * Copyright (c) 2005 - 2013 Profactor GmbH, ACIN
+ *               2020 Johannes Kepler University Linz
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License 2.0 which is available at
  * http://www.eclipse.org/legal/epl-2.0.
@@ -10,11 +11,15 @@
  *    Thomas Strasser, Ingomar Müller, Alois Zoitl, Gerhard Ebenhofer
  *    Ingo Hegny, Monika Wenger
  *      - initial implementation and rework communication infrastructure
+ *    Ernst Blecha - add multibit partial access
  *******************************************************************************/
 #ifndef _FORTE_DWORD_H_
 #define _FORTE_DWORD_H_
 
 #include "forte_any_bit.h"
+#include "forte_bool.h"
+#include "forte_byte.h"
+#include "forte_word.h"
 #include <limits>
 
 /*!\ingroup COREDTS CIEC_DWORD represents the dword data type according to IEC 61131.
@@ -76,6 +81,27 @@ class CIEC_DWORD : public CIEC_ANY_BIT{
     virtual EDataTypeID getDataTypeID() const{
       return CIEC_ANY::e_DWORD;
     }
+
+    /*! \brief Access a single bit within a CIEC_DWORD (e.g. [DWORD].X<1>())
+     *
+     */
+    template <size_t paIndex> PARTIAL_ACCESS_BIT<CIEC_BOOL, CIEC_DWORD, paIndex> X(){
+      return PARTIAL_ACCESS_BIT<CIEC_BOOL,CIEC_DWORD, paIndex>(*this);
+    }
+
+    /*! \brief Access a single byte within a CIEC_DWORD (e.g. [DWORD].B<1>())
+     *
+     */
+    template <size_t paIndex> PARTIAL_ACCESS<CIEC_BYTE, CIEC_DWORD, paIndex> B(){
+      return PARTIAL_ACCESS<CIEC_BYTE, CIEC_DWORD, paIndex>(*this);
+    }
+
+    /*! \brief Access a single word within a CIEC_DWORD (e.g. [DWORD].W<1>())
+     *
+     */
+    template <size_t paIndex> PARTIAL_ACCESS<CIEC_WORD, CIEC_DWORD, paIndex> W(){
+      return PARTIAL_ACCESS<CIEC_WORD, CIEC_DWORD, paIndex>(*this);
+    }
 };
 
 #endif /*_FORTE_DWORD_H_*/
diff --git a/src/core/datatypes/forte_lword.h b/src/core/datatypes/forte_lword.h
index 83ce4fc56..547723c1b 100644
--- a/src/core/datatypes/forte_lword.h
+++ b/src/core/datatypes/forte_lword.h
@@ -1,6 +1,6 @@
 /*******************************************************************************
  * Copyright (c) 2010 - 2013 ACIN
- *
+ *               2020 Johannes Kepler University Linz
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License 2.0 which is available at
  * http://www.eclipse.org/legal/epl-2.0.
@@ -10,11 +10,16 @@
  * Contributors:
  *    Martin Melik Merkiumians, Alois Zoitl, Monika Wenger
  *      - initial implementation and rework communication infrastructure
+ *    Ernst Blecha - add multibit partial access
   *******************************************************************************/
 #ifndef _FORTE_LWORD_H_
 #define _FORTE_LWORD_H_
 
 #include "forte_any_bit.h"
+#include "forte_bool.h"
+#include "forte_byte.h"
+#include "forte_word.h"
+#include "forte_dword.h"
 #include <limits>
 
 #ifdef FORTE_USE_64BIT_DATATYPES
@@ -78,6 +83,34 @@ class CIEC_LWORD : public CIEC_ANY_BIT{
     virtual EDataTypeID getDataTypeID() const{
       return CIEC_ANY::e_LWORD;
     }
+
+    /*! \brief Access a single bit within a CIEC_LWORD (e.g. [LWORD].X<1>())
+     *
+     */
+    template <size_t paIndex> PARTIAL_ACCESS_BIT<CIEC_BOOL, CIEC_LWORD, paIndex> X(){
+      return PARTIAL_ACCESS_BIT<CIEC_BOOL, CIEC_LWORD, paIndex>(*this);
+    }
+
+    /*! \brief Access a single byte within a CIEC_LWORD (e.g. [LWORD].B<1>())
+     *
+     */
+    template <size_t paIndex> PARTIAL_ACCESS<CIEC_BYTE, CIEC_LWORD, paIndex> B(){
+      return PARTIAL_ACCESS<CIEC_BYTE, CIEC_LWORD, paIndex>(*this);
+    }
+
+    /*! \brief Access a single word within a CIEC_LWORD (e.g. [LWORD].W<1>())
+     *
+     */
+    template <size_t paIndex> PARTIAL_ACCESS<CIEC_WORD, CIEC_LWORD, paIndex> W(){
+      return PARTIAL_ACCESS<CIEC_WORD, CIEC_LWORD, paIndex>(*this);
+    }
+
+    /*! \brief Access a single Dword within a CIEC_LWORD (e.g. [LWORD].D<1>())
+     *
+     */
+    template <size_t paIndex> PARTIAL_ACCESS<CIEC_DWORD, CIEC_LWORD, paIndex> D(){
+      return PARTIAL_ACCESS<CIEC_DWORD, CIEC_LWORD, paIndex>(*this);
+    }
 };
 
 #endif
diff --git a/src/core/datatypes/forte_word.h b/src/core/datatypes/forte_word.h
index b2399abc6..b912f3175 100644
--- a/src/core/datatypes/forte_word.h
+++ b/src/core/datatypes/forte_word.h
@@ -1,5 +1,6 @@
 /*******************************************************************************
  * Copyright (c) 2005 - 2013 Profactor GmbH, ACIN
+ *               2020 Johannes Kepler University Linz
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License 2.0 which is available at
  * http://www.eclipse.org/legal/epl-2.0.
@@ -10,11 +11,14 @@
  *    Thomas Strasser, Ingomar Müller, Alois Zoitl, Gerhard Ebenhofer, Ingo Hegny,
  *    Monika Wenger
  *      - initial implementation and rework communication infrastructure
+ *    Ernst Blecha - add multibit partial access
  *******************************************************************************/
 #ifndef _FORTE_WORD_H_
 #define _FORTE_WORD_H_
 
 #include "forte_any_bit.h"
+#include "forte_bool.h"
+#include "forte_byte.h"
 #include <limits>
 
 /*!\ingroup COREDTS CIEC_WORD represents the word data type according to IEC 61131.
@@ -76,6 +80,20 @@ class CIEC_WORD : public CIEC_ANY_BIT{
     virtual EDataTypeID getDataTypeID() const{
       return CIEC_ANY::e_WORD;
     }
+
+    /*! \brief Access a single bit within a CIEC_WORD (e.g. [WORD].X<1>())
+     *
+     */
+    template <size_t paIndex> PARTIAL_ACCESS_BIT<CIEC_BOOL, CIEC_WORD, paIndex> X(){
+      return PARTIAL_ACCESS_BIT<CIEC_BOOL, CIEC_WORD, paIndex>(*this);
+    }
+
+    /*! \brief Access a single byte within a CIEC_WORD (e.g. [WORD].B<1>())
+     *
+     */
+    template <size_t paIndex> PARTIAL_ACCESS<CIEC_BYTE, CIEC_WORD, paIndex> B(){
+      return PARTIAL_ACCESS<CIEC_BYTE, CIEC_WORD, paIndex>(*this);
+    }
 };
 
 #endif /*_FORTE_WORD_H_*/
diff --git a/tests/core/datatypes/CIEC_PARTIAL/CIEC_BYTE_PARTIAL_test.cpp b/tests/core/datatypes/CIEC_PARTIAL/CIEC_BYTE_PARTIAL_test.cpp
new file mode 100644
index 000000000..2fa819eae
--- /dev/null
+++ b/tests/core/datatypes/CIEC_PARTIAL/CIEC_BYTE_PARTIAL_test.cpp
@@ -0,0 +1,172 @@
+/*******************************************************************************
+ * Copyright (c) 2011 - 2012 ACIN, nxtControl, 2018 TU Vienna/ACIN
+ *               2020 Johannes Kepler University Linz
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *   Martin Melik Merkumians, Ingo Hegny, Alois Zoitl, Stanislav Meduna - initial API and implementation and/or initial documentation
+ *   Ernst Blecha - Adds partial access tests
+ *******************************************************************************/
+
+#include <boost/test/unit_test.hpp>
+
+/*#ifdef FORTE_USE_REAL_DATATYPE
+  #include <boost/test/floating_point_comparison.hpp>
+
+  #include "../../../src/core/datatypes/forte_real.h"
+#endif //FORTE_USE_REAL_DATATYPE*/
+
+//BOOLEAN
+#include "../../../src/core/datatypes/forte_bool.h"
+//BIT-Datatypes
+#include "../../../src/core/datatypes/forte_byte.h"
+
+#include "CIEC_PARTIAL_test.h"
+
+using namespace boost::unit_test;
+
+BOOST_AUTO_TEST_SUITE(CIEC_ANY_BIT_PARTIAL)
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_BYTE_INITVALUES)
+{
+  CIEC_BYTE nTestByte;
+
+  test4X_0(nTestByte,4);
+  test4X_0(nTestByte,0);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_BYTE_VALUE1_CHECK_BYTE)
+{
+  CIEC_BYTE nTestByte;
+
+  nTestByte=0xBE;
+  BOOST_CHECK_EQUAL(nTestByte, 0xBEU);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_BYTE_VALUE2_CHECK_BYTE)
+{
+  CIEC_BYTE nTestByte;
+
+  nTestByte=0xBA;
+  BOOST_CHECK_EQUAL(nTestByte, 0xBAU);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_BYTE_VALUE1_CHECK_BIT)
+{
+  CIEC_BYTE nTestByte;
+
+  nTestByte=0xBE;
+  test4X_B(nTestByte,4);
+  test4X_E(nTestByte,0);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_BYTE_VALUE2_CHECK_BIT)
+{
+  CIEC_BYTE nTestByte;
+
+  nTestByte=0xBA;
+  test4X_B(nTestByte,4);
+  test4X_A(nTestByte,0);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_BYTE_VALUE_CHANGE_CHECK_BYTE)
+{
+  CIEC_BYTE nTestByte;
+
+  nTestByte=0xBE;
+  nTestByte=0xBA;
+  BOOST_CHECK_EQUAL(nTestByte, 0xBAU);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_BYTE_VALUE_CHANGE_CHECK_BIT)
+{
+  CIEC_BYTE nTestByte;
+
+  nTestByte=0xBE;
+  nTestByte=0xBA;
+  test4X_B(nTestByte,4);
+  test4X_A(nTestByte,0);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_BYTE_ASSIGN_BIT_CHANGE_BYTE_CHECK_BYTE_A)
+{
+  CIEC_BYTE nTestByte;
+
+  set4X_0(nTestByte,4);
+  set4X_D(nTestByte,0);
+
+  nTestByte = 0xFE;
+
+  BOOST_CHECK_EQUAL(nTestByte, 0xFEU);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_BYTE_ASSIGN_BIT_CHANGE_BYTE_CHECK_BYTE_B)
+{
+  CIEC_BYTE nTestByte;
+
+  set4X_0(nTestByte,4);
+  set4X_D(nTestByte,0);
+
+  nTestByte = 0xFE;
+
+  nTestByte = 0x22;
+
+  BOOST_CHECK_EQUAL(nTestByte, 0x22U);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_BYTE_ASSIGN_BIT_CHECK_BIT)
+{
+  CIEC_BYTE nTestByte;
+
+  set4X_0(nTestByte,4);
+  set4X_D(nTestByte,0);
+
+  test4X_0(nTestByte,4);
+  test4X_D(nTestByte,0);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_BYTE_ASSIGN_BIT_CHANGE_BYTE_CHECK_BIT_A)
+{
+  CIEC_BYTE nTestByte;
+
+  set4X_0(nTestByte,4);
+  set4X_D(nTestByte,0);
+
+  nTestByte = 0xFE;
+
+  test4X_F(nTestByte,4);
+  test4X_E(nTestByte,0);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_BYTE_ASSIGN_BIT_CHANGE_BYTE_CHECK_BIT_B)
+{
+  CIEC_BYTE nTestByte;
+
+  set4X_0(nTestByte,4);
+  set4X_D(nTestByte,0);
+
+  nTestByte = 0xFE;
+
+  nTestByte = 0x22;
+
+  test4X_2(nTestByte,4);
+  test4X_2(nTestByte,0);
+
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/tests/core/datatypes/CIEC_PARTIAL/CIEC_DWORD_PARTIAL_test.cpp b/tests/core/datatypes/CIEC_PARTIAL/CIEC_DWORD_PARTIAL_test.cpp
new file mode 100644
index 000000000..9b0ffdf60
--- /dev/null
+++ b/tests/core/datatypes/CIEC_PARTIAL/CIEC_DWORD_PARTIAL_test.cpp
@@ -0,0 +1,1192 @@
+/*******************************************************************************
+ * Copyright (c) 2011 - 2012 ACIN, nxtControl, 2018 TU Vienna/ACIN
+ *               2020 Johannes Kepler University Linz
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *   Martin Melik Merkumians, Ingo Hegny, Alois Zoitl, Stanislav Meduna - initial API and implementation and/or initial documentation
+ *   Ernst Blecha - Adds partial access tests
+ *******************************************************************************/
+
+#include <boost/test/unit_test.hpp>
+
+/*#ifdef FORTE_USE_REAL_DATATYPE
+  #include <boost/test/floating_point_comparison.hpp>
+
+  #include "../../../src/core/datatypes/forte_real.h"
+#endif //FORTE_USE_REAL_DATATYPE*/
+
+//BOOLEAN
+#include "../../../src/core/datatypes/forte_bool.h"
+//BIT-Datatypes
+#include "../../../src/core/datatypes/forte_byte.h"
+#include "../../../src/core/datatypes/forte_word.h"
+#include "../../../src/core/datatypes/forte_dword.h"
+
+#include "CIEC_PARTIAL_test.h"
+
+using namespace boost::unit_test;
+
+BOOST_AUTO_TEST_SUITE(CIEC_ANY_BIT_PARTIAL)
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_INITVALUES_CHECK_BIT)
+{
+  CIEC_DWORD nTestDWord;
+
+  test4X_0(nTestDWord,28);
+  test4X_0(nTestDWord,24);
+  test4X_0(nTestDWord,20);
+  test4X_0(nTestDWord,16);
+  test4X_0(nTestDWord,12);
+  test4X_0(nTestDWord,8);
+  test4X_0(nTestDWord,4);
+  test4X_0(nTestDWord,0);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_INITVALUES_CHECK_BYTE)
+{
+  CIEC_DWORD nTestDWord;
+
+  BOOST_CHECK_EQUAL(nTestDWord.B<0>(),0);
+  BOOST_CHECK_EQUAL(nTestDWord.B<1>(),0);
+  BOOST_CHECK_EQUAL(nTestDWord.B<2>(),0);
+  BOOST_CHECK_EQUAL(nTestDWord.B<3>(),0);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_INITVALUES_CHECK_WORD)
+{
+  CIEC_DWORD nTestDWord;
+
+  BOOST_CHECK_EQUAL(nTestDWord.W<0>(),0);
+  BOOST_CHECK_EQUAL(nTestDWord.W<1>(),0);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_INITVALUES_CHECK_DWORD)
+{
+  CIEC_DWORD nTestDWord;
+
+  BOOST_CHECK_EQUAL(nTestDWord,0);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_VALUE_CHECK_BIT)
+{
+  CIEC_DWORD nTestDWord;
+
+  nTestDWord=0xCAFEBABE;
+
+  test4X_C(nTestDWord,28)
+  test4X_A(nTestDWord,24)
+  test4X_F(nTestDWord,20)
+  test4X_E(nTestDWord,16)
+
+  test4X_B(nTestDWord,12)
+  test4X_A(nTestDWord,8)
+  test4X_B(nTestDWord,4)
+  test4X_E(nTestDWord,0)
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_VALUE_CHECK_BYTE)
+{
+  CIEC_DWORD nTestDWord;
+
+  nTestDWord=0xCAFEBABE;
+
+  BOOST_CHECK_EQUAL(nTestDWord.B<0>(), 0xBE);
+  BOOST_CHECK_EQUAL(nTestDWord.B<1>(), 0xBA);
+  BOOST_CHECK_EQUAL(nTestDWord.B<2>(), 0xFE);
+  BOOST_CHECK_EQUAL(nTestDWord.B<3>(), 0xCA);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_VALUE_CHECK_WORD)
+{
+  CIEC_DWORD nTestDWord;
+
+  nTestDWord=0xCAFEBABE;
+
+  BOOST_CHECK_EQUAL(nTestDWord.W<0>(), 0xBABE);
+  BOOST_CHECK_EQUAL(nTestDWord.W<1>(), 0xCAFE);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_VALUE_CHECK_DWORD)
+{
+  CIEC_DWORD nTestDWord;
+
+  nTestDWord=0xCAFEBABE;
+
+  BOOST_CHECK_EQUAL(nTestDWord, 0xCAFEBABE);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_ASSIGN)
+{
+  CIEC_DWORD nTestDWord;
+
+  set4X_B(nTestDWord,28);
+  set4X_A(nTestDWord,24);
+  set4X_A(nTestDWord,20);
+  set4X_D(nTestDWord,16);
+  set4X_F(nTestDWord,12);
+  set4X_0(nTestDWord,8);
+  set4X_0(nTestDWord,4);
+  set4X_D(nTestDWord,0);
+
+  test4X_B(nTestDWord,28);
+  test4X_A(nTestDWord,24);
+  test4X_A(nTestDWord,20);
+  test4X_D(nTestDWord,16);
+  test4X_F(nTestDWord,12);
+  test4X_0(nTestDWord,8);
+  test4X_0(nTestDWord,4);
+  test4X_D(nTestDWord,0);
+
+  BOOST_CHECK_EQUAL(nTestDWord.B<3>(), 0xBAU);
+  BOOST_CHECK_EQUAL(nTestDWord.B<2>(), 0xADU);
+  BOOST_CHECK_EQUAL(nTestDWord.B<1>(), 0xF0U);
+  BOOST_CHECK_EQUAL(nTestDWord.B<0>(), 0x0DU);
+  BOOST_CHECK_EQUAL(nTestDWord.W<1>(), 0xBAADU);
+  BOOST_CHECK_EQUAL(nTestDWord.W<0>(), 0xF00DU);
+  BOOST_CHECK_EQUAL(nTestDWord, 0xBAADF00DU);
+
+  nTestDWord.B<3>() = 0xBA;
+  nTestDWord.B<2>() = 0xD0;
+  nTestDWord.B<1>() = 0xCA;
+  nTestDWord.B<0>() = 0xFE;
+
+  test4X_B(nTestDWord,28);
+  test4X_A(nTestDWord,24);
+  test4X_D(nTestDWord,20);
+  test4X_0(nTestDWord,16);
+  test4X_C(nTestDWord,12);
+  test4X_A(nTestDWord,8);
+  test4X_F(nTestDWord,4);
+  test4X_E(nTestDWord,0);
+
+  BOOST_CHECK_EQUAL(nTestDWord.B<3>(), 0xBAU);
+  BOOST_CHECK_EQUAL(nTestDWord.B<2>(), 0xD0U);
+  BOOST_CHECK_EQUAL(nTestDWord.B<1>(), 0xCAU);
+  BOOST_CHECK_EQUAL(nTestDWord.B<0>(), 0xFEU);
+  BOOST_CHECK_EQUAL(nTestDWord.W<1>(), 0xBAD0U);
+  BOOST_CHECK_EQUAL(nTestDWord.W<0>(), 0xCAFEU);
+  BOOST_CHECK_EQUAL(nTestDWord, 0xBAD0CAFEU);
+
+  nTestDWord.W<1>() = 0xCEC0;
+  nTestDWord.W<0>() = 0xFFEE;
+
+  test4X_C(nTestDWord,28);
+  test4X_E(nTestDWord,24);
+  test4X_C(nTestDWord,20);
+  test4X_0(nTestDWord,16);
+  test4X_F(nTestDWord,12);
+  test4X_F(nTestDWord,8);
+  test4X_E(nTestDWord,4);
+  test4X_E(nTestDWord,0);
+
+  BOOST_CHECK_EQUAL(nTestDWord.B<3>(), 0xCEU);
+  BOOST_CHECK_EQUAL(nTestDWord.B<2>(), 0xC0U);
+  BOOST_CHECK_EQUAL(nTestDWord.B<1>(), 0xFFU);
+  BOOST_CHECK_EQUAL(nTestDWord.B<0>(), 0xEEU);
+  BOOST_CHECK_EQUAL(nTestDWord.W<1>(), 0xCEC0U);
+  BOOST_CHECK_EQUAL(nTestDWord.W<0>(), 0xFFEEU);
+  BOOST_CHECK_EQUAL(nTestDWord, 0xCEC0FFEEU);
+
+  nTestDWord = 0xADD511FE;
+
+  test4X_A(nTestDWord,28);
+  test4X_D(nTestDWord,24);
+  test4X_D(nTestDWord,20);
+  test4X_5(nTestDWord,16);
+  test4X_1(nTestDWord,12);
+  test4X_1(nTestDWord,8);
+  test4X_F(nTestDWord,4);
+  test4X_E(nTestDWord,0);
+
+  BOOST_CHECK_EQUAL(nTestDWord.B<3>(), 0xADU);
+  BOOST_CHECK_EQUAL(nTestDWord.B<2>(), 0xD5U);
+  BOOST_CHECK_EQUAL(nTestDWord.B<1>(), 0x11U);
+  BOOST_CHECK_EQUAL(nTestDWord.B<0>(), 0xFEU);
+  BOOST_CHECK_EQUAL(nTestDWord.W<1>(), 0xADD5U);
+  BOOST_CHECK_EQUAL(nTestDWord.W<0>(), 0x11FEU);
+  BOOST_CHECK_EQUAL(nTestDWord, 0xADD511FEU);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_ASSIGN_CHAIN_SET_BIT_CHECK_BIT)
+{
+  CIEC_DWORD nTestDWord;
+
+  set4X_B(nTestDWord,28);
+  set4X_A(nTestDWord,24);
+  set4X_A(nTestDWord,20);
+  set4X_D(nTestDWord,16);
+  set4X_F(nTestDWord,12);
+  set4X_0(nTestDWord,8);
+  set4X_0(nTestDWord,4);
+  set4X_D(nTestDWord,0);
+
+  test4X_B(nTestDWord,28);
+  test4X_A(nTestDWord,24);
+  test4X_A(nTestDWord,20);
+  test4X_D(nTestDWord,16);
+  test4X_F(nTestDWord,12);
+  test4X_0(nTestDWord,8);
+  test4X_0(nTestDWord,4);
+  test4X_D(nTestDWord,0);
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_ASSIGN_CHAIN_SET_BIT_CHECK_BYTE)
+{
+  CIEC_DWORD nTestDWord;
+
+  set4X_B(nTestDWord,28);
+  set4X_A(nTestDWord,24);
+  set4X_A(nTestDWord,20);
+  set4X_D(nTestDWord,16);
+  set4X_F(nTestDWord,12);
+  set4X_0(nTestDWord,8);
+  set4X_0(nTestDWord,4);
+  set4X_D(nTestDWord,0);
+
+  BOOST_CHECK_EQUAL(nTestDWord.B<3>(), 0xBAU);
+  BOOST_CHECK_EQUAL(nTestDWord.B<2>(), 0xADU);
+  BOOST_CHECK_EQUAL(nTestDWord.B<1>(), 0xF0U);
+  BOOST_CHECK_EQUAL(nTestDWord.B<0>(), 0x0DU);
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_ASSIGN_CHAIN_SET_BIT_CHECK_WORD)
+{
+  CIEC_DWORD nTestDWord;
+
+  set4X_B(nTestDWord,28);
+  set4X_A(nTestDWord,24);
+  set4X_A(nTestDWord,20);
+  set4X_D(nTestDWord,16);
+  set4X_F(nTestDWord,12);
+  set4X_0(nTestDWord,8);
+  set4X_0(nTestDWord,4);
+  set4X_D(nTestDWord,0);
+
+  BOOST_CHECK_EQUAL(nTestDWord.W<1>(), 0xBAADU);
+  BOOST_CHECK_EQUAL(nTestDWord.W<0>(), 0xF00DU);
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_ASSIGN_CHAIN_SET_BIT_CHECK_DWORD)
+{
+  CIEC_DWORD nTestDWord;
+
+  set4X_B(nTestDWord,28);
+  set4X_A(nTestDWord,24);
+  set4X_A(nTestDWord,20);
+  set4X_D(nTestDWord,16);
+  set4X_F(nTestDWord,12);
+  set4X_0(nTestDWord,8);
+  set4X_0(nTestDWord,4);
+  set4X_D(nTestDWord,0);
+
+  BOOST_CHECK_EQUAL(nTestDWord, 0xBAADF00DU);
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_CHANGE_CHAIN_SET_BYTE_CHECK_BIT)
+{
+  CIEC_DWORD nTestDWord;
+
+  set4X_B(nTestDWord,28);
+  set4X_A(nTestDWord,24);
+  set4X_A(nTestDWord,20);
+  set4X_D(nTestDWord,16);
+  set4X_F(nTestDWord,12);
+  set4X_0(nTestDWord,8);
+  set4X_0(nTestDWord,4);
+  set4X_D(nTestDWord,0);
+
+  nTestDWord.B<3>() = 0xBA;
+  nTestDWord.B<2>() = 0xD0;
+  nTestDWord.B<1>() = 0xCA;
+  nTestDWord.B<0>() = 0xFE;
+
+  test4X_B(nTestDWord,28);
+  test4X_A(nTestDWord,24);
+  test4X_D(nTestDWord,20);
+  test4X_0(nTestDWord,16);
+  test4X_C(nTestDWord,12);
+  test4X_A(nTestDWord,8);
+  test4X_F(nTestDWord,4);
+  test4X_E(nTestDWord,0);
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_CHANGE_CHAIN_SET_BYTE_CHECK_BYTE)
+{
+  CIEC_DWORD nTestDWord;
+
+  set4X_B(nTestDWord,28);
+  set4X_A(nTestDWord,24);
+  set4X_A(nTestDWord,20);
+  set4X_D(nTestDWord,16);
+  set4X_F(nTestDWord,12);
+  set4X_0(nTestDWord,8);
+  set4X_0(nTestDWord,4);
+  set4X_D(nTestDWord,0);
+
+  nTestDWord.B<3>() = 0xBA;
+  nTestDWord.B<2>() = 0xD0;
+  nTestDWord.B<1>() = 0xCA;
+  nTestDWord.B<0>() = 0xFE;
+
+  BOOST_CHECK_EQUAL(nTestDWord.B<3>(), 0xBAU);
+  BOOST_CHECK_EQUAL(nTestDWord.B<2>(), 0xD0U);
+  BOOST_CHECK_EQUAL(nTestDWord.B<1>(), 0xCAU);
+  BOOST_CHECK_EQUAL(nTestDWord.B<0>(), 0xFEU);
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_CHANGE_CHAIN_SET_BYTE_CHECK_WORD)
+{
+  CIEC_DWORD nTestDWord;
+
+  set4X_B(nTestDWord,28);
+  set4X_A(nTestDWord,24);
+  set4X_A(nTestDWord,20);
+  set4X_D(nTestDWord,16);
+  set4X_F(nTestDWord,12);
+  set4X_0(nTestDWord,8);
+  set4X_0(nTestDWord,4);
+  set4X_D(nTestDWord,0);
+
+  nTestDWord.B<3>() = 0xBA;
+  nTestDWord.B<2>() = 0xD0;
+  nTestDWord.B<1>() = 0xCA;
+  nTestDWord.B<0>() = 0xFE;
+
+  BOOST_CHECK_EQUAL(nTestDWord.W<1>(), 0xBAD0U);
+  BOOST_CHECK_EQUAL(nTestDWord.W<0>(), 0xCAFEU);
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_CHANGE_CHAIN_SET_BYTE_CHECK_DWORD)
+{
+  CIEC_DWORD nTestDWord;
+
+  set4X_B(nTestDWord,28);
+  set4X_A(nTestDWord,24);
+  set4X_A(nTestDWord,20);
+  set4X_D(nTestDWord,16);
+  set4X_F(nTestDWord,12);
+  set4X_0(nTestDWord,8);
+  set4X_0(nTestDWord,4);
+  set4X_D(nTestDWord,0);
+
+  nTestDWord.B<3>() = 0xBA;
+  nTestDWord.B<2>() = 0xD0;
+  nTestDWord.B<1>() = 0xCA;
+  nTestDWord.B<0>() = 0xFE;
+
+  BOOST_CHECK_EQUAL(nTestDWord, 0xBAD0CAFEU);
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_CHANGE_CHAIN_SET_WORD_CHECK_BIT)
+{
+  CIEC_DWORD nTestDWord;
+
+  set4X_B(nTestDWord,28);
+  set4X_A(nTestDWord,24);
+  set4X_A(nTestDWord,20);
+  set4X_D(nTestDWord,16);
+  set4X_F(nTestDWord,12);
+  set4X_0(nTestDWord,8);
+  set4X_0(nTestDWord,4);
+  set4X_D(nTestDWord,0);
+
+  nTestDWord.B<3>() = 0xBA;
+  nTestDWord.B<2>() = 0xD0;
+  nTestDWord.B<1>() = 0xCA;
+  nTestDWord.B<0>() = 0xFE;
+
+  nTestDWord.W<1>() = 0xCEC0;
+  nTestDWord.W<0>() = 0xFFEE;
+
+  test4X_C(nTestDWord,28);
+  test4X_E(nTestDWord,24);
+  test4X_C(nTestDWord,20);
+  test4X_0(nTestDWord,16);
+  test4X_F(nTestDWord,12);
+  test4X_F(nTestDWord,8);
+  test4X_E(nTestDWord,4);
+  test4X_E(nTestDWord,0);
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_CHANGE_CHAIN_SET_WORD_CHECK_BYTE)
+{
+  CIEC_DWORD nTestDWord;
+
+  set4X_B(nTestDWord,28);
+  set4X_A(nTestDWord,24);
+  set4X_A(nTestDWord,20);
+  set4X_D(nTestDWord,16);
+  set4X_F(nTestDWord,12);
+  set4X_0(nTestDWord,8);
+  set4X_0(nTestDWord,4);
+  set4X_D(nTestDWord,0);
+
+  nTestDWord.B<3>() = 0xBA;
+  nTestDWord.B<2>() = 0xD0;
+  nTestDWord.B<1>() = 0xCA;
+  nTestDWord.B<0>() = 0xFE;
+
+  nTestDWord.W<1>() = 0xCEC0;
+  nTestDWord.W<0>() = 0xFFEE;
+
+  BOOST_CHECK_EQUAL(nTestDWord.B<3>(), 0xCEU);
+  BOOST_CHECK_EQUAL(nTestDWord.B<2>(), 0xC0U);
+  BOOST_CHECK_EQUAL(nTestDWord.B<1>(), 0xFFU);
+  BOOST_CHECK_EQUAL(nTestDWord.B<0>(), 0xEEU);
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_CHANGE_CHAIN_SET_WORD_CHECK_WORD)
+{
+  CIEC_DWORD nTestDWord;
+
+  set4X_B(nTestDWord,28);
+  set4X_A(nTestDWord,24);
+  set4X_A(nTestDWord,20);
+  set4X_D(nTestDWord,16);
+  set4X_F(nTestDWord,12);
+  set4X_0(nTestDWord,8);
+  set4X_0(nTestDWord,4);
+  set4X_D(nTestDWord,0);
+
+  nTestDWord.B<3>() = 0xBA;
+  nTestDWord.B<2>() = 0xD0;
+  nTestDWord.B<1>() = 0xCA;
+  nTestDWord.B<0>() = 0xFE;
+
+  nTestDWord.W<1>() = 0xCEC0;
+  nTestDWord.W<0>() = 0xFFEE;
+
+  BOOST_CHECK_EQUAL(nTestDWord.W<1>(), 0xCEC0U);
+  BOOST_CHECK_EQUAL(nTestDWord.W<0>(), 0xFFEEU);
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_CHANGE_CHAIN_SET_WORD_CHECK_DWORD)
+{
+  CIEC_DWORD nTestDWord;
+
+  set4X_B(nTestDWord,28);
+  set4X_A(nTestDWord,24);
+  set4X_A(nTestDWord,20);
+  set4X_D(nTestDWord,16);
+  set4X_F(nTestDWord,12);
+  set4X_0(nTestDWord,8);
+  set4X_0(nTestDWord,4);
+  set4X_D(nTestDWord,0);
+
+  nTestDWord.B<3>() = 0xBA;
+  nTestDWord.B<2>() = 0xD0;
+  nTestDWord.B<1>() = 0xCA;
+  nTestDWord.B<0>() = 0xFE;
+
+  nTestDWord.W<1>() = 0xCEC0;
+  nTestDWord.W<0>() = 0xFFEE;
+
+  BOOST_CHECK_EQUAL(nTestDWord, 0xCEC0FFEEU);
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_CHANGE_CHAIN_WORD_SET_BIT_CHECK_BIT)
+{
+  CIEC_DWORD nTestDWord;
+
+  set4X_B(nTestDWord,28);
+  set4X_A(nTestDWord,24);
+  set4X_A(nTestDWord,20);
+  set4X_D(nTestDWord,16);
+  set4X_F(nTestDWord,12);
+  set4X_0(nTestDWord,8);
+  set4X_0(nTestDWord,4);
+  set4X_D(nTestDWord,0);
+
+  nTestDWord.B<3>() = 0xBA;
+  nTestDWord.B<2>() = 0xD0;
+  nTestDWord.B<1>() = 0xCA;
+  nTestDWord.B<0>() = 0xFE;
+
+  nTestDWord.W<1>() = 0xCEC0;
+  nTestDWord.W<0>() = 0xFFEE;
+
+  set4X_A(nTestDWord.W<1>(),12);
+  set4X_D(nTestDWord.W<1>(),8);
+  set4X_D(nTestDWord.W<1>(),4);
+  set4X_5(nTestDWord.W<1>(),0);
+  set4X_1(nTestDWord.W<0>(),12);
+  set4X_1(nTestDWord.W<0>(),8);
+  set4X_F(nTestDWord.W<0>(),4);
+  set4X_E(nTestDWord.W<0>(),0);
+
+  test4X_A(nTestDWord,28);
+  test4X_D(nTestDWord,24);
+  test4X_D(nTestDWord,20);
+  test4X_5(nTestDWord,16);
+  test4X_1(nTestDWord,12);
+  test4X_1(nTestDWord,8);
+  test4X_F(nTestDWord,4);
+  test4X_E(nTestDWord,0);
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_CHANGE_CHAIN_WORD_SET_BIT_CHECK_BYTE)
+{
+  CIEC_DWORD nTestDWord;
+
+  set4X_B(nTestDWord,28);
+  set4X_A(nTestDWord,24);
+  set4X_A(nTestDWord,20);
+  set4X_D(nTestDWord,16);
+  set4X_F(nTestDWord,12);
+  set4X_0(nTestDWord,8);
+  set4X_0(nTestDWord,4);
+  set4X_D(nTestDWord,0);
+
+  nTestDWord.B<3>() = 0xBA;
+  nTestDWord.B<2>() = 0xD0;
+  nTestDWord.B<1>() = 0xCA;
+  nTestDWord.B<0>() = 0xFE;
+
+  nTestDWord.W<1>() = 0xCEC0;
+  nTestDWord.W<0>() = 0xFFEE;
+
+  set4X_A(nTestDWord.W<1>(),12);
+  set4X_D(nTestDWord.W<1>(),8);
+  set4X_D(nTestDWord.W<1>(),4);
+  set4X_5(nTestDWord.W<1>(),0);
+  set4X_1(nTestDWord.W<0>(),12);
+  set4X_1(nTestDWord.W<0>(),8);
+  set4X_F(nTestDWord.W<0>(),4);
+  set4X_E(nTestDWord.W<0>(),0);
+
+  BOOST_CHECK_EQUAL(nTestDWord.B<3>(), 0xADU);
+  BOOST_CHECK_EQUAL(nTestDWord.B<2>(), 0xD5U);
+  BOOST_CHECK_EQUAL(nTestDWord.B<1>(), 0x11U);
+  BOOST_CHECK_EQUAL(nTestDWord.B<0>(), 0xFEU);
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_CHANGE_CHAIN_WORD_SET_BIT_CHECK_WORD)
+{
+  CIEC_DWORD nTestDWord;
+
+  set4X_B(nTestDWord,28);
+  set4X_A(nTestDWord,24);
+  set4X_A(nTestDWord,20);
+  set4X_D(nTestDWord,16);
+  set4X_F(nTestDWord,12);
+  set4X_0(nTestDWord,8);
+  set4X_0(nTestDWord,4);
+  set4X_D(nTestDWord,0);
+
+  nTestDWord.B<3>() = 0xBA;
+  nTestDWord.B<2>() = 0xD0;
+  nTestDWord.B<1>() = 0xCA;
+  nTestDWord.B<0>() = 0xFE;
+
+  nTestDWord.W<1>() = 0xCEC0;
+  nTestDWord.W<0>() = 0xFFEE;
+
+  set4X_A(nTestDWord.W<1>(),12);
+  set4X_D(nTestDWord.W<1>(),8);
+  set4X_D(nTestDWord.W<1>(),4);
+  set4X_5(nTestDWord.W<1>(),0);
+  set4X_1(nTestDWord.W<0>(),12);
+  set4X_1(nTestDWord.W<0>(),8);
+  set4X_F(nTestDWord.W<0>(),4);
+  set4X_E(nTestDWord.W<0>(),0);
+
+  BOOST_CHECK_EQUAL(nTestDWord.W<1>(), 0xADD5U);
+  BOOST_CHECK_EQUAL(nTestDWord.W<0>(), 0x11FEU);
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_CHANGE_CHAIN_WORD_SET_BIT_CHECK_DWORD)
+{
+  CIEC_DWORD nTestDWord;
+
+  nTestDWord.B<3>() = 0xBA;
+  nTestDWord.B<2>() = 0xD0;
+  nTestDWord.B<1>() = 0xCA;
+  nTestDWord.B<0>() = 0xFE;
+
+  nTestDWord.W<1>() = 0xCEC0;
+  nTestDWord.W<0>() = 0xFFEE;
+
+  set4X_A(nTestDWord.W<1>(),12);
+  set4X_D(nTestDWord.W<1>(),8);
+  set4X_D(nTestDWord.W<1>(),4);
+  set4X_5(nTestDWord.W<1>(),0);
+  set4X_1(nTestDWord.W<0>(),12);
+  set4X_1(nTestDWord.W<0>(),8);
+  set4X_F(nTestDWord.W<0>(),4);
+  set4X_E(nTestDWord.W<0>(),0);
+
+  BOOST_CHECK_EQUAL(nTestDWord, 0xADD511FEU);
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_CHANGE_CHAIN_WORD_BYTE_SET_BIT_CHECK_BIT)
+{
+  CIEC_DWORD nTestDWord;
+
+  set4X_C(nTestDWord.W<1>().B<1>(),4);
+  set4X_E(nTestDWord.W<1>().B<1>(),0);
+  set4X_C(nTestDWord.W<1>().B<0>(),4);
+  set4X_0(nTestDWord.W<1>().B<0>(),0);
+  set4X_F(nTestDWord.W<0>().B<1>(),4);
+  set4X_F(nTestDWord.W<0>().B<1>(),0);
+  set4X_E(nTestDWord.W<0>().B<0>(),4);
+  set4X_E(nTestDWord.W<0>().B<0>(),0);
+
+  test4X_C(nTestDWord,28);
+  test4X_E(nTestDWord,24);
+  test4X_C(nTestDWord,20);
+  test4X_0(nTestDWord,16);
+  test4X_F(nTestDWord,12);
+  test4X_F(nTestDWord,8);
+  test4X_E(nTestDWord,4);
+  test4X_E(nTestDWord,0);
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_CHANGE_CHAIN_WORD_BYTE_SET_BIT_CHECK_WORD_BIT)
+{
+  CIEC_DWORD nTestDWord;
+
+  set4X_C(nTestDWord.W<1>().B<1>(),4);
+  set4X_E(nTestDWord.W<1>().B<1>(),0);
+  set4X_C(nTestDWord.W<1>().B<0>(),4);
+  set4X_0(nTestDWord.W<1>().B<0>(),0);
+  set4X_F(nTestDWord.W<0>().B<1>(),4);
+  set4X_F(nTestDWord.W<0>().B<1>(),0);
+  set4X_E(nTestDWord.W<0>().B<0>(),4);
+  set4X_E(nTestDWord.W<0>().B<0>(),0);
+
+  test4X_C(nTestDWord.W<1>(),12);
+  test4X_E(nTestDWord.W<1>(),8);
+  test4X_C(nTestDWord.W<1>(),4);
+  test4X_0(nTestDWord.W<1>(),0);
+  test4X_F(nTestDWord.W<0>(),12);
+  test4X_F(nTestDWord.W<0>(),8);
+  test4X_E(nTestDWord.W<0>(),4);
+  test4X_E(nTestDWord.W<0>(),0);
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_CHANGE_CHAIN_WORD_BYTE_SET_BIT_CHECK_WORD_BYTE_BIT)
+{
+  CIEC_DWORD nTestDWord;
+
+  set4X_C(nTestDWord.W<1>().B<1>(),4);
+  set4X_E(nTestDWord.W<1>().B<1>(),0);
+  set4X_C(nTestDWord.W<1>().B<0>(),4);
+  set4X_0(nTestDWord.W<1>().B<0>(),0);
+  set4X_F(nTestDWord.W<0>().B<1>(),4);
+  set4X_F(nTestDWord.W<0>().B<1>(),0);
+  set4X_E(nTestDWord.W<0>().B<0>(),4);
+  set4X_E(nTestDWord.W<0>().B<0>(),0);
+
+  test4X_C(nTestDWord.W<1>().B<1>(),4);
+  test4X_E(nTestDWord.W<1>().B<1>(),0);
+  test4X_C(nTestDWord.W<1>().B<0>(),4);
+  test4X_0(nTestDWord.W<1>().B<0>(),0);
+  test4X_F(nTestDWord.W<0>().B<1>(),4);
+  test4X_F(nTestDWord.W<0>().B<1>(),0);
+  test4X_E(nTestDWord.W<0>().B<0>(),4);
+  test4X_E(nTestDWord.W<0>().B<0>(),0);
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_CHANGE_CHAIN_WORD_BYTE_SET_BIT_CHECK_WORD_BYTE)
+{
+  CIEC_DWORD nTestDWord;
+
+  set4X_C(nTestDWord.W<1>().B<1>(),4);
+  set4X_E(nTestDWord.W<1>().B<1>(),0);
+  set4X_C(nTestDWord.W<1>().B<0>(),4);
+  set4X_0(nTestDWord.W<1>().B<0>(),0);
+  set4X_F(nTestDWord.W<0>().B<1>(),4);
+  set4X_F(nTestDWord.W<0>().B<1>(),0);
+  set4X_E(nTestDWord.W<0>().B<0>(),4);
+  set4X_E(nTestDWord.W<0>().B<0>(),0);
+
+  BOOST_CHECK_EQUAL(nTestDWord.W<1>().B<1>(), 0xCEU);
+  BOOST_CHECK_EQUAL(nTestDWord.W<1>().B<0>(), 0xC0U);
+  BOOST_CHECK_EQUAL(nTestDWord.W<0>().B<1>(), 0xFFU);
+  BOOST_CHECK_EQUAL(nTestDWord.W<0>().B<0>(), 0xEEU);
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_CHANGE_CHAIN_WORD_BYTE_SET_BIT_CHECK_BYTE)
+{
+  CIEC_DWORD nTestDWord;
+
+  set4X_C(nTestDWord.W<1>().B<1>(),4);
+  set4X_E(nTestDWord.W<1>().B<1>(),0);
+  set4X_C(nTestDWord.W<1>().B<0>(),4);
+  set4X_0(nTestDWord.W<1>().B<0>(),0);
+  set4X_F(nTestDWord.W<0>().B<1>(),4);
+  set4X_F(nTestDWord.W<0>().B<1>(),0);
+  set4X_E(nTestDWord.W<0>().B<0>(),4);
+  set4X_E(nTestDWord.W<0>().B<0>(),0);
+
+  BOOST_CHECK_EQUAL(nTestDWord.B<3>(), 0xCEU);
+  BOOST_CHECK_EQUAL(nTestDWord.B<2>(), 0xC0U);
+  BOOST_CHECK_EQUAL(nTestDWord.B<1>(), 0xFFU);
+  BOOST_CHECK_EQUAL(nTestDWord.B<0>(), 0xEEU);
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_CHANGE_CHAIN_WORD_BYTE_SET_BIT_CHECK_WORD)
+{
+  CIEC_DWORD nTestDWord;
+
+  set4X_A(nTestDWord.W<1>(),12);
+  set4X_D(nTestDWord.W<1>(),8);
+  set4X_D(nTestDWord.W<1>(),4);
+  set4X_5(nTestDWord.W<1>(),0);
+  set4X_1(nTestDWord.W<0>(),12);
+  set4X_1(nTestDWord.W<0>(),8);
+  set4X_F(nTestDWord.W<0>(),4);
+  set4X_E(nTestDWord.W<0>(),0);
+
+  set4X_C(nTestDWord.W<1>().B<1>(),4);
+  set4X_E(nTestDWord.W<1>().B<1>(),0);
+  set4X_C(nTestDWord.W<1>().B<0>(),4);
+  set4X_0(nTestDWord.W<1>().B<0>(),0);
+  set4X_F(nTestDWord.W<0>().B<1>(),4);
+  set4X_F(nTestDWord.W<0>().B<1>(),0);
+  set4X_E(nTestDWord.W<0>().B<0>(),4);
+  set4X_E(nTestDWord.W<0>().B<0>(),0);
+
+  BOOST_CHECK_EQUAL(nTestDWord.W<1>(), 0xCEC0U);
+  BOOST_CHECK_EQUAL(nTestDWord.W<0>(), 0xFFEEU);
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_CHANGE_CHAIN_WORD_BYTE_SET_BIT_CHECK_DWORD)
+{
+  CIEC_DWORD nTestDWord;
+
+  set4X_A(nTestDWord.W<1>(),12);
+  set4X_D(nTestDWord.W<1>(),8);
+  set4X_D(nTestDWord.W<1>(),4);
+  set4X_5(nTestDWord.W<1>(),0);
+  set4X_1(nTestDWord.W<0>(),12);
+  set4X_1(nTestDWord.W<0>(),8);
+  set4X_F(nTestDWord.W<0>(),4);
+  set4X_E(nTestDWord.W<0>(),0);
+
+  set4X_C(nTestDWord.W<1>().B<1>(),4);
+  set4X_E(nTestDWord.W<1>().B<1>(),0);
+  set4X_C(nTestDWord.W<1>().B<0>(),4);
+  set4X_0(nTestDWord.W<1>().B<0>(),0);
+  set4X_F(nTestDWord.W<0>().B<1>(),4);
+  set4X_F(nTestDWord.W<0>().B<1>(),0);
+  set4X_E(nTestDWord.W<0>().B<0>(),4);
+  set4X_E(nTestDWord.W<0>().B<0>(),0);
+
+  BOOST_CHECK_EQUAL(nTestDWord, 0xCEC0FFEEU);
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_SET_VALUE_WORD_A_CHECK_WORD)
+{
+  CIEC_DWORD nTestDWord;
+  CIEC_WORD nTestWord;
+
+  nTestWord = 0xCAFE;
+
+  nTestDWord.W<0>().setValue(nTestWord);
+  BOOST_CHECK_EQUAL(nTestDWord.W<1>(), 0x0000);
+  BOOST_CHECK_EQUAL(nTestDWord.W<0>(), 0xCAFE);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_SET_VALUE_WORD_A_CHECK_DWORD)
+{
+  CIEC_DWORD nTestDWord;
+  CIEC_WORD nTestWord;
+
+  nTestWord = 0xCAFE;
+  nTestDWord.W<0>().setValue(nTestWord);
+
+  BOOST_CHECK_EQUAL(nTestDWord, 0x0000CAFE);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_SET_VALUE_WORD_B_CHECK_WORD)
+{
+  CIEC_DWORD nTestDWord;
+  CIEC_WORD nTestWord;
+
+  nTestWord = 0xCAFE;
+  nTestDWord.W<0>().setValue(nTestWord);
+
+  nTestWord = 0xBAD0;
+  nTestDWord.W<1>().setValue(nTestWord);
+
+  BOOST_CHECK_EQUAL(nTestDWord.W<1>(), 0xBAD0);
+  BOOST_CHECK_EQUAL(nTestDWord.W<0>(), 0xCAFE);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_SET_VALUE_WORD_B_CHECK_DWORD)
+{
+  CIEC_DWORD nTestDWord;
+  CIEC_WORD nTestWord;
+
+  nTestWord = 0xCAFE;
+  nTestDWord.W<0>().setValue(nTestWord);
+
+  nTestWord = 0xBAD0;
+  nTestDWord.W<1>().setValue(nTestWord);
+
+  BOOST_CHECK_EQUAL(nTestDWord, 0xBAD0CAFE);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_SET_VALUE_BYTE_CHECK_BYTE)
+{
+  CIEC_DWORD nTestDWord;
+  CIEC_WORD nTestWord;
+  CIEC_BYTE nTestByte;
+
+  nTestWord = 0xCAFE;
+  nTestDWord.W<0>().setValue(nTestWord);
+
+  nTestWord = 0xBAD0;
+  nTestDWord.W<1>().setValue(nTestWord);
+
+  nTestByte = 0x0B;
+  nTestDWord.B<1>().setValue(nTestByte);
+  BOOST_CHECK_EQUAL(nTestDWord.B<3>(), 0xBA);
+  BOOST_CHECK_EQUAL(nTestDWord.B<2>(), 0xD0);
+  BOOST_CHECK_EQUAL(nTestDWord.B<1>(), 0x0B);
+  BOOST_CHECK_EQUAL(nTestDWord.B<0>(), 0xFE);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_SET_VALUE_BYTE_CHECK_WORD)
+{
+  CIEC_DWORD nTestDWord;
+  CIEC_WORD nTestWord;
+  CIEC_BYTE nTestByte;
+
+  nTestWord = 0xCAFE;
+  nTestDWord.W<0>().setValue(nTestWord);
+
+  nTestWord = 0xBAD0;
+  nTestDWord.W<1>().setValue(nTestWord);
+
+  nTestByte = 0x0B;
+  nTestDWord.B<1>().setValue(nTestByte);
+
+  BOOST_CHECK_EQUAL(nTestDWord.W<1>(), 0xBAD0);
+  BOOST_CHECK_EQUAL(nTestDWord.W<0>(), 0x0BFE);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_SET_VALUE_BYTE_CHECK_DWORD)
+{
+  CIEC_DWORD nTestDWord;
+  CIEC_WORD nTestWord;
+  CIEC_BYTE nTestByte;
+
+  nTestWord = 0xCAFE;
+  nTestDWord.W<0>().setValue(nTestWord);
+
+  nTestWord = 0xBAD0;
+  nTestDWord.W<1>().setValue(nTestWord);
+
+  nTestByte = 0x0B;
+  nTestDWord.B<1>().setValue(nTestByte);
+
+  BOOST_CHECK_EQUAL(nTestDWord, 0xBAD00BFE);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_SET_VALUE_WORD_BYTE_CHECK_BYTE)
+{
+  CIEC_DWORD nTestDWord;
+  CIEC_WORD nTestWord;
+  CIEC_BYTE nTestByte;
+
+  nTestWord = 0xCAFE;
+  nTestDWord.W<0>().setValue(nTestWord);
+
+  nTestWord = 0xBAD0;
+  nTestDWord.W<1>().setValue(nTestWord);
+
+  nTestByte = 0x0B;
+  nTestDWord.B<1>().setValue(nTestByte);
+
+  nTestByte = 0xAD;
+  nTestDWord.W<0>().B<0>().setValue(nTestByte);
+
+  BOOST_CHECK_EQUAL(nTestDWord.B<0>(), 0xAD);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_SET_VALUE_WORD_BYTE_CHECK_WORD)
+{
+  CIEC_DWORD nTestDWord;
+  CIEC_WORD nTestWord;
+  CIEC_BYTE nTestByte;
+
+  nTestWord = 0xCAFE;
+  nTestDWord.W<0>().setValue(nTestWord);
+
+  nTestWord = 0xBAD0;
+  nTestDWord.W<1>().setValue(nTestWord);
+
+  nTestByte = 0x0B;
+  nTestDWord.B<1>().setValue(nTestByte);
+
+  nTestByte = 0xAD;
+  nTestDWord.W<0>().B<0>().setValue(nTestByte);
+
+  BOOST_CHECK_EQUAL(nTestDWord.W<0>(), 0x0BAD);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_SET_VALUE_WORD_BYTE_CHECK_DWORD)
+{
+  CIEC_DWORD nTestDWord;
+  CIEC_WORD nTestWord;
+  CIEC_BYTE nTestByte;
+
+  nTestWord = 0xCAFE;
+  nTestDWord.W<0>().setValue(nTestWord);
+
+  nTestWord = 0xBAD0;
+  nTestDWord.W<1>().setValue(nTestWord);
+
+  nTestByte = 0x0B;
+  nTestDWord.B<1>().setValue(nTestByte);
+
+  nTestByte = 0xAD;
+  nTestDWord.W<0>().B<0>().setValue(nTestByte);
+
+  BOOST_CHECK_EQUAL(nTestDWord, 0xBAD00BAD);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_SET_VALUE_WORD_BYTE_BIT_CHECK_BIT_A)
+{
+  CIEC_DWORD nTestDWord;
+  CIEC_WORD nTestWord;
+  CIEC_BYTE nTestByte;
+  CIEC_BOOL nTestBool;
+
+  nTestWord = 0xCAFE;
+  nTestDWord.W<0>().setValue(nTestWord);
+
+  nTestWord = 0xBAD0;
+  nTestDWord.W<1>().setValue(nTestWord);
+
+  nTestByte = 0x0B;
+  nTestDWord.B<1>().setValue(nTestByte);
+
+  nTestByte = 0xAD;
+  nTestDWord.W<0>().B<0>().setValue(nTestByte);
+
+  nTestBool = false;
+  nTestDWord.W<0>().B<0>().X<0>().setValue(nTestBool);
+
+  BOOST_CHECK_EQUAL(nTestDWord.X<0>(), false);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_SET_VALUE_WORD_BYTE_BIT_CHECK_BYTE_A)
+{
+  CIEC_DWORD nTestDWord;
+  CIEC_WORD nTestWord;
+  CIEC_BYTE nTestByte;
+  CIEC_BOOL nTestBool;
+
+  nTestWord = 0xCAFE;
+  nTestDWord.W<0>().setValue(nTestWord);
+
+  nTestWord = 0xBAD0;
+  nTestDWord.W<1>().setValue(nTestWord);
+
+  nTestByte = 0x0B;
+  nTestDWord.B<1>().setValue(nTestByte);
+
+  nTestByte = 0xAD;
+  nTestDWord.W<0>().B<0>().setValue(nTestByte);
+
+  nTestBool = false;
+  nTestDWord.W<0>().B<0>().X<0>().setValue(nTestBool);
+
+  BOOST_CHECK_EQUAL(nTestDWord.B<0>(), 0xAC);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_SET_VALUE_WORD_BYTE_BIT_CHECK_WORD_A)
+{
+  CIEC_DWORD nTestDWord;
+  CIEC_WORD nTestWord;
+  CIEC_BYTE nTestByte;
+  CIEC_BOOL nTestBool;
+
+  nTestWord = 0xCAFE;
+  nTestDWord.W<0>().setValue(nTestWord);
+
+  nTestWord = 0xBAD0;
+  nTestDWord.W<1>().setValue(nTestWord);
+
+  nTestByte = 0x0B;
+  nTestDWord.B<1>().setValue(nTestByte);
+
+  nTestByte = 0xAD;
+  nTestDWord.W<0>().B<0>().setValue(nTestByte);
+
+  nTestBool = false;
+  nTestDWord.W<0>().B<0>().X<0>().setValue(nTestBool);
+
+  BOOST_CHECK_EQUAL(nTestDWord.W<0>(), 0x0BAC);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_SET_VALUE_WORD_BYTE_BIT_CHECK_DWORD_A)
+{
+  CIEC_DWORD nTestDWord;
+  CIEC_WORD nTestWord;
+  CIEC_BYTE nTestByte;
+  CIEC_BOOL nTestBool;
+
+  nTestWord = 0xCAFE;
+  nTestDWord.W<0>().setValue(nTestWord);
+
+  nTestWord = 0xBAD0;
+  nTestDWord.W<1>().setValue(nTestWord);
+
+  nTestByte = 0x0B;
+  nTestDWord.B<1>().setValue(nTestByte);
+
+  nTestByte = 0xAD;
+  nTestDWord.W<0>().B<0>().setValue(nTestByte);
+
+  nTestBool = false;
+  nTestDWord.W<0>().B<0>().X<0>().setValue(nTestBool);
+
+  BOOST_CHECK_EQUAL(nTestDWord, 0xBAD00BAC);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_SET_VALUE_WORD_BYTE_BIT_CHECK_BIT_B)
+{
+  CIEC_DWORD nTestDWord;
+  CIEC_WORD nTestWord;
+  CIEC_BYTE nTestByte;
+  CIEC_BOOL nTestBool;
+
+  nTestWord = 0xCAFE;
+  nTestDWord.W<0>().setValue(nTestWord);
+
+  nTestWord = 0xBAD0;
+  nTestDWord.W<1>().setValue(nTestWord);
+
+  nTestByte = 0x0B;
+  nTestDWord.B<1>().setValue(nTestByte);
+
+  nTestByte = 0xAD;
+  nTestDWord.W<0>().B<0>().setValue(nTestByte);
+
+  nTestBool = false;
+  nTestDWord.W<0>().B<0>().X<0>().setValue(nTestBool);
+
+  BOOST_CHECK_EQUAL(nTestDWord.X<0>(), false);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_SET_VALUE_WORD_BYTE_BIT_CHECK_BYTE_B)
+{
+  CIEC_DWORD nTestDWord;
+  CIEC_WORD nTestWord;
+  CIEC_BYTE nTestByte;
+  CIEC_BOOL nTestBool;
+
+  nTestWord = 0xCAFE;
+  nTestDWord.W<0>().setValue(nTestWord);
+
+  nTestWord = 0xBAD0;
+  nTestDWord.W<1>().setValue(nTestWord);
+
+  nTestByte = 0x0B;
+  nTestDWord.B<1>().setValue(nTestByte);
+
+  nTestByte = 0xAD;
+  nTestDWord.W<0>().B<0>().setValue(nTestByte);
+
+  nTestBool = false;
+  nTestDWord.W<0>().B<0>().X<0>().setValue(nTestBool);
+
+  nTestBool = true;
+  nTestDWord.W<1>().B<0>().X<5>().setValue(nTestBool);
+
+  BOOST_CHECK_EQUAL(nTestDWord.B<2>(), 0xF0);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_SET_VALUE_WORD_BYTE_BIT_CHECK_WORD_B)
+{
+  CIEC_DWORD nTestDWord;
+  CIEC_WORD nTestWord;
+  CIEC_BYTE nTestByte;
+  CIEC_BOOL nTestBool;
+
+  nTestWord = 0xCAFE;
+  nTestDWord.W<0>().setValue(nTestWord);
+
+  nTestWord = 0xBAD0;
+  nTestDWord.W<1>().setValue(nTestWord);
+
+  nTestByte = 0x0B;
+  nTestDWord.B<1>().setValue(nTestByte);
+
+  nTestByte = 0xAD;
+  nTestDWord.W<0>().B<0>().setValue(nTestByte);
+
+  nTestBool = false;
+  nTestDWord.W<0>().B<0>().X<0>().setValue(nTestBool);
+
+  nTestBool = true;
+  nTestDWord.W<1>().B<0>().X<5>().setValue(nTestBool);
+
+  BOOST_CHECK_EQUAL(nTestDWord.W<1>(), 0xBAF0);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_DWORD_SET_VALUE_WORD_BYTE_BIT_CHECK_DWORD_B)
+{
+  CIEC_DWORD nTestDWord;
+  CIEC_WORD nTestWord;
+  CIEC_BYTE nTestByte;
+  CIEC_BOOL nTestBool;
+
+  nTestWord = 0xCAFE;
+  nTestDWord.W<0>().setValue(nTestWord);
+
+  nTestWord = 0xBAD0;
+  nTestDWord.W<1>().setValue(nTestWord);
+
+  nTestByte = 0x0B;
+  nTestDWord.B<1>().setValue(nTestByte);
+
+  nTestByte = 0xAD;
+  nTestDWord.W<0>().B<0>().setValue(nTestByte);
+
+  nTestBool = false;
+  nTestDWord.W<0>().B<0>().X<0>().setValue(nTestBool);
+
+  nTestBool = true;
+  nTestDWord.W<1>().B<0>().X<5>().setValue(nTestBool);
+
+  BOOST_CHECK_EQUAL(nTestDWord, 0xBAF00BAC);
+
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/tests/core/datatypes/CIEC_PARTIAL/CIEC_LWORD_PARTIAL_test.cpp b/tests/core/datatypes/CIEC_PARTIAL/CIEC_LWORD_PARTIAL_test.cpp
new file mode 100644
index 000000000..f5a96b565
--- /dev/null
+++ b/tests/core/datatypes/CIEC_PARTIAL/CIEC_LWORD_PARTIAL_test.cpp
@@ -0,0 +1,849 @@
+/*******************************************************************************
+ * Copyright (c) 2011 - 2012 ACIN, nxtControl, 2018 TU Vienna/ACIN
+ *               2020 Johannes Kepler University Linz
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *   Martin Melik Merkumians, Ingo Hegny, Alois Zoitl, Stanislav Meduna - initial API and implementation and/or initial documentation
+ *   Ernst Blecha - Adds partial access tests
+ *******************************************************************************/
+
+#include <boost/test/unit_test.hpp>
+
+/*#ifdef FORTE_USE_REAL_DATATYPE
+  #include <boost/test/floating_point_comparison.hpp>
+
+  #include "../../../src/core/datatypes/forte_real.h"
+#endif //FORTE_USE_REAL_DATATYPE*/
+
+//BOOLEAN
+#include "../../../src/core/datatypes/forte_bool.h"
+//BIT-Datatypes
+#include "../../../src/core/datatypes/forte_byte.h"
+#include "../../../src/core/datatypes/forte_word.h"
+#include "../../../src/core/datatypes/forte_dword.h"
+#ifdef FORTE_USE_64BIT_DATATYPES
+  #include "../../../src/core/datatypes/forte_lword.h"
+#endif //#ifdef FORTE_USE_64BIT_DATATYPES
+
+#include "CIEC_PARTIAL_test.h"
+
+using namespace boost::unit_test;
+
+BOOST_AUTO_TEST_SUITE(CIEC_ANY_BIT_PARTIAL)
+
+#ifdef FORTE_USE_64BIT_DATATYPES
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_INITVALUES_CHECK_BIT)
+{
+  CIEC_LWORD nTestLWord;
+
+  test4X_0(nTestLWord, 60);
+  test4X_0(nTestLWord, 56);
+  test4X_0(nTestLWord, 52);
+  test4X_0(nTestLWord, 48);
+
+  test4X_0(nTestLWord, 44);
+  test4X_0(nTestLWord, 40);
+  test4X_0(nTestLWord, 36);
+  test4X_0(nTestLWord, 32);
+
+  test4X_0(nTestLWord, 28);
+  test4X_0(nTestLWord, 24);
+  test4X_0(nTestLWord, 20);
+  test4X_0(nTestLWord, 16);
+
+  test4X_0(nTestLWord, 12);
+  test4X_0(nTestLWord, 8);
+  test4X_0(nTestLWord, 4);
+  test4X_0(nTestLWord, 0);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_INITVALUES_CHECK_BYTE)
+{
+  CIEC_LWORD nTestLWord;
+
+  BOOST_CHECK_EQUAL(nTestLWord.B<0>(),0);
+  BOOST_CHECK_EQUAL(nTestLWord.B<1>(),0);
+  BOOST_CHECK_EQUAL(nTestLWord.B<2>(),0);
+  BOOST_CHECK_EQUAL(nTestLWord.B<3>(),0);
+  BOOST_CHECK_EQUAL(nTestLWord.B<4>(),0);
+  BOOST_CHECK_EQUAL(nTestLWord.B<5>(),0);
+  BOOST_CHECK_EQUAL(nTestLWord.B<6>(),0);
+  BOOST_CHECK_EQUAL(nTestLWord.B<7>(),0);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_INITVALUES_CHECK_WORD)
+{
+  CIEC_LWORD nTestLWord;
+
+  BOOST_CHECK_EQUAL(nTestLWord.W<0>(),0);
+  BOOST_CHECK_EQUAL(nTestLWord.W<1>(),0);
+  BOOST_CHECK_EQUAL(nTestLWord.W<2>(),0);
+  BOOST_CHECK_EQUAL(nTestLWord.W<3>(),0);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_INITVALUES_CHECK_DWORD)
+{
+  CIEC_LWORD nTestLWord;
+
+  BOOST_CHECK_EQUAL(nTestLWord.D<0>(),0);
+  BOOST_CHECK_EQUAL(nTestLWord.D<1>(),0);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_VALUE_CHECK_BIT)
+{
+  CIEC_LWORD nTestLWord;
+
+  nTestLWord=0xDEADBEEFCAFEBABEU;
+
+  test4X_D(nTestLWord, 60)
+  test4X_E(nTestLWord, 56)
+  test4X_A(nTestLWord, 52)
+  test4X_D(nTestLWord, 48)
+
+  test4X_B(nTestLWord, 44)
+  test4X_E(nTestLWord, 40)
+  test4X_E(nTestLWord, 36)
+  test4X_F(nTestLWord, 32)
+
+  test4X_C(nTestLWord, 28)
+  test4X_A(nTestLWord, 24)
+  test4X_F(nTestLWord, 20)
+  test4X_E(nTestLWord, 16)
+
+  test4X_B(nTestLWord, 12)
+  test4X_A(nTestLWord, 8)
+  test4X_B(nTestLWord, 4)
+  test4X_E(nTestLWord, 0)
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_VALUE_CHECK_BYTE)
+{
+  CIEC_LWORD nTestLWord;
+
+  nTestLWord=0xDEADBEEFCAFEBABEU;
+
+  BOOST_CHECK_EQUAL(nTestLWord.B<0>(), 0xBE);
+  BOOST_CHECK_EQUAL(nTestLWord.B<1>(), 0xBA);
+  BOOST_CHECK_EQUAL(nTestLWord.B<2>(), 0xFE);
+  BOOST_CHECK_EQUAL(nTestLWord.B<3>(), 0xCA);
+  BOOST_CHECK_EQUAL(nTestLWord.B<4>(), 0xEF);
+  BOOST_CHECK_EQUAL(nTestLWord.B<5>(), 0xBE);
+  BOOST_CHECK_EQUAL(nTestLWord.B<6>(), 0xAD);
+  BOOST_CHECK_EQUAL(nTestLWord.B<7>(), 0xDE);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_VALUE_CHECK_WORD)
+{
+  CIEC_LWORD nTestLWord;
+
+  nTestLWord=0xDEADBEEFCAFEBABEU;
+
+  BOOST_CHECK_EQUAL(nTestLWord.W<0>(), 0xBABE);
+  BOOST_CHECK_EQUAL(nTestLWord.W<1>(), 0xCAFE);
+  BOOST_CHECK_EQUAL(nTestLWord.W<2>(), 0xBEEF);
+  BOOST_CHECK_EQUAL(nTestLWord.W<3>(), 0xDEAD);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_VALUE_CHECK_DWORD)
+{
+  CIEC_LWORD nTestLWord;
+
+  nTestLWord=0xDEADBEEFCAFEBABEU;
+
+  BOOST_CHECK_EQUAL(nTestLWord.D<0>(), 0xCAFEBABEU);
+  BOOST_CHECK_EQUAL(nTestLWord.D<1>(), 0xDEADBEEFU);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_ASSIGN_BIT_CHECK_BIT)
+{
+  CIEC_LWORD nTestLWord;
+
+  set4X_B(nTestLWord,60);
+  set4X_A(nTestLWord,56);
+  set4X_D(nTestLWord,52);
+  set4X_C(nTestLWord,48);
+  set4X_A(nTestLWord,44);
+  set4X_B(nTestLWord,40);
+  set4X_1(nTestLWord,36);
+  set4X_E(nTestLWord,32);
+  set4X_B(nTestLWord,28);
+  set4X_A(nTestLWord,24);
+  set4X_A(nTestLWord,20);
+  set4X_D(nTestLWord,16);
+  set4X_F(nTestLWord,12);
+  set4X_0(nTestLWord,8);
+  set4X_0(nTestLWord,4);
+  set4X_D(nTestLWord,0);
+
+  test4X_B(nTestLWord,60);
+  test4X_A(nTestLWord,56);
+  test4X_D(nTestLWord,52);
+  test4X_C(nTestLWord,48);
+  test4X_A(nTestLWord,44);
+  test4X_B(nTestLWord,40);
+  test4X_1(nTestLWord,36);
+  test4X_E(nTestLWord,32);
+  test4X_B(nTestLWord,28);
+  test4X_A(nTestLWord,24);
+  test4X_A(nTestLWord,20);
+  test4X_D(nTestLWord,16);
+  test4X_F(nTestLWord,12);
+  test4X_0(nTestLWord,8);
+  test4X_0(nTestLWord,4);
+  test4X_D(nTestLWord,0);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_ASSIGN_BIT_CHECK_BYTE)
+{
+  CIEC_LWORD nTestLWord;
+
+  set4X_B(nTestLWord,60);
+  set4X_A(nTestLWord,56);
+  set4X_D(nTestLWord,52);
+  set4X_C(nTestLWord,48);
+  set4X_A(nTestLWord,44);
+  set4X_B(nTestLWord,40);
+  set4X_1(nTestLWord,36);
+  set4X_E(nTestLWord,32);
+  set4X_B(nTestLWord,28);
+  set4X_A(nTestLWord,24);
+  set4X_A(nTestLWord,20);
+  set4X_D(nTestLWord,16);
+  set4X_F(nTestLWord,12);
+  set4X_0(nTestLWord,8);
+  set4X_0(nTestLWord,4);
+  set4X_D(nTestLWord,0);
+
+  BOOST_CHECK_EQUAL(nTestLWord.B<7>(), 0xBAU);
+  BOOST_CHECK_EQUAL(nTestLWord.B<6>(), 0xDCU);
+  BOOST_CHECK_EQUAL(nTestLWord.B<5>(), 0xABU);
+  BOOST_CHECK_EQUAL(nTestLWord.B<4>(), 0x1EU);
+  BOOST_CHECK_EQUAL(nTestLWord.B<3>(), 0xBAU);
+  BOOST_CHECK_EQUAL(nTestLWord.B<2>(), 0xADU);
+  BOOST_CHECK_EQUAL(nTestLWord.B<1>(), 0xF0U);
+  BOOST_CHECK_EQUAL(nTestLWord.B<0>(), 0x0DU);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_ASSIGN_BIT_CHECK_WORD)
+{
+  CIEC_LWORD nTestLWord;
+
+  set4X_B(nTestLWord,60);
+  set4X_A(nTestLWord,56);
+  set4X_D(nTestLWord,52);
+  set4X_C(nTestLWord,48);
+  set4X_A(nTestLWord,44);
+  set4X_B(nTestLWord,40);
+  set4X_1(nTestLWord,36);
+  set4X_E(nTestLWord,32);
+  set4X_B(nTestLWord,28);
+  set4X_A(nTestLWord,24);
+  set4X_A(nTestLWord,20);
+  set4X_D(nTestLWord,16);
+  set4X_F(nTestLWord,12);
+  set4X_0(nTestLWord,8);
+  set4X_0(nTestLWord,4);
+  set4X_D(nTestLWord,0);
+
+  BOOST_CHECK_EQUAL(nTestLWord.W<3>(), 0xBADCU);
+  BOOST_CHECK_EQUAL(nTestLWord.W<2>(), 0xAB1EU);
+  BOOST_CHECK_EQUAL(nTestLWord.W<1>(), 0xBAADU);
+  BOOST_CHECK_EQUAL(nTestLWord.W<0>(), 0xF00DU);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_ASSIGN_BIT_CHECK_DWORD)
+{
+  CIEC_LWORD nTestLWord;
+
+  set4X_B(nTestLWord,60);
+  set4X_A(nTestLWord,56);
+  set4X_D(nTestLWord,52);
+  set4X_C(nTestLWord,48);
+  set4X_A(nTestLWord,44);
+  set4X_B(nTestLWord,40);
+  set4X_1(nTestLWord,36);
+  set4X_E(nTestLWord,32);
+  set4X_B(nTestLWord,28);
+  set4X_A(nTestLWord,24);
+  set4X_A(nTestLWord,20);
+  set4X_D(nTestLWord,16);
+  set4X_F(nTestLWord,12);
+  set4X_0(nTestLWord,8);
+  set4X_0(nTestLWord,4);
+  set4X_D(nTestLWord,0);
+
+  BOOST_CHECK_EQUAL(nTestLWord.D<1>(), 0xBADCAB1EU);
+  BOOST_CHECK_EQUAL(nTestLWord.D<0>(), 0xBAADF00DU);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_ASSIGN_BIT_CHECK_LWORD)
+{
+  CIEC_LWORD nTestLWord;
+
+  set4X_B(nTestLWord,60);
+  set4X_A(nTestLWord,56);
+  set4X_D(nTestLWord,52);
+  set4X_C(nTestLWord,48);
+  set4X_A(nTestLWord,44);
+  set4X_B(nTestLWord,40);
+  set4X_1(nTestLWord,36);
+  set4X_E(nTestLWord,32);
+  set4X_B(nTestLWord,28);
+  set4X_A(nTestLWord,24);
+  set4X_A(nTestLWord,20);
+  set4X_D(nTestLWord,16);
+  set4X_F(nTestLWord,12);
+  set4X_0(nTestLWord,8);
+  set4X_0(nTestLWord,4);
+  set4X_D(nTestLWord,0);
+
+  BOOST_CHECK_EQUAL(nTestLWord, 0xBADCAB1EBAADF00DU);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_ASSIGN_BYTE_CHECK_BIT)
+{
+  CIEC_LWORD nTestLWord;
+
+  nTestLWord.B<7>() = 0xDE;
+  nTestLWord.B<6>() = 0xCA;
+  nTestLWord.B<5>() = 0xFB;
+  nTestLWord.B<4>() = 0xAD;
+  nTestLWord.B<3>() = 0xBA;
+  nTestLWord.B<2>() = 0xD0;
+  nTestLWord.B<1>() = 0xCA;
+  nTestLWord.B<0>() = 0xFE;
+
+  test4X_D(nTestLWord,60);
+  test4X_E(nTestLWord,56);
+  test4X_C(nTestLWord,52);
+  test4X_A(nTestLWord,48);
+  test4X_F(nTestLWord,44);
+  test4X_B(nTestLWord,40);
+  test4X_A(nTestLWord,36);
+  test4X_D(nTestLWord,32);
+  test4X_B(nTestLWord,28);
+  test4X_A(nTestLWord,24);
+  test4X_D(nTestLWord,20);
+  test4X_0(nTestLWord,16);
+  test4X_C(nTestLWord,12);
+  test4X_A(nTestLWord,8);
+  test4X_F(nTestLWord,4);
+  test4X_E(nTestLWord,0);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_ASSIGN_BYTE_CHECK_BYTE)
+{
+  CIEC_LWORD nTestLWord;
+
+  nTestLWord.B<7>() = 0xDE;
+  nTestLWord.B<6>() = 0xCA;
+  nTestLWord.B<5>() = 0xFB;
+  nTestLWord.B<4>() = 0xAD;
+  nTestLWord.B<3>() = 0xBA;
+  nTestLWord.B<2>() = 0xD0;
+  nTestLWord.B<1>() = 0xCA;
+  nTestLWord.B<0>() = 0xFE;
+
+  BOOST_CHECK_EQUAL(nTestLWord.B<7>(), 0xDEU);
+  BOOST_CHECK_EQUAL(nTestLWord.B<6>(), 0xCAU);
+  BOOST_CHECK_EQUAL(nTestLWord.B<5>(), 0xFBU);
+  BOOST_CHECK_EQUAL(nTestLWord.B<4>(), 0xADU);
+  BOOST_CHECK_EQUAL(nTestLWord.B<3>(), 0xBAU);
+  BOOST_CHECK_EQUAL(nTestLWord.B<2>(), 0xD0U);
+  BOOST_CHECK_EQUAL(nTestLWord.B<1>(), 0xCAU);
+  BOOST_CHECK_EQUAL(nTestLWord.B<0>(), 0xFEU);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_ASSIGN_BYTE_CHECK_WORD)
+{
+  CIEC_LWORD nTestLWord;
+
+  nTestLWord.B<7>() = 0xDE;
+  nTestLWord.B<6>() = 0xCA;
+  nTestLWord.B<5>() = 0xFB;
+  nTestLWord.B<4>() = 0xAD;
+  nTestLWord.B<3>() = 0xBA;
+  nTestLWord.B<2>() = 0xD0;
+  nTestLWord.B<1>() = 0xCA;
+  nTestLWord.B<0>() = 0xFE;
+
+  BOOST_CHECK_EQUAL(nTestLWord.W<3>(), 0xDECAU);
+  BOOST_CHECK_EQUAL(nTestLWord.W<2>(), 0xFBADU);
+  BOOST_CHECK_EQUAL(nTestLWord.W<1>(), 0xBAD0U);
+  BOOST_CHECK_EQUAL(nTestLWord.W<0>(), 0xCAFEU);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_ASSIGN_BYTE_CHECK_DWORD)
+{
+  CIEC_LWORD nTestLWord;
+
+  nTestLWord.B<7>() = 0xDE;
+  nTestLWord.B<6>() = 0xCA;
+  nTestLWord.B<5>() = 0xFB;
+  nTestLWord.B<4>() = 0xAD;
+  nTestLWord.B<3>() = 0xBA;
+  nTestLWord.B<2>() = 0xD0;
+  nTestLWord.B<1>() = 0xCA;
+  nTestLWord.B<0>() = 0xFE;
+
+  BOOST_CHECK_EQUAL(nTestLWord.D<1>(), 0xDECAFBADU);
+  BOOST_CHECK_EQUAL(nTestLWord.D<0>(), 0xBAD0CAFEU);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_ASSIGN_BYTE_CHECK_LWORD)
+{
+  CIEC_LWORD nTestLWord;
+
+  nTestLWord.B<7>() = 0xDE;
+  nTestLWord.B<6>() = 0xCA;
+  nTestLWord.B<5>() = 0xFB;
+  nTestLWord.B<4>() = 0xAD;
+  nTestLWord.B<3>() = 0xBA;
+  nTestLWord.B<2>() = 0xD0;
+  nTestLWord.B<1>() = 0xCA;
+  nTestLWord.B<0>() = 0xFE;
+
+
+  BOOST_CHECK_EQUAL(nTestLWord, 0xDECAFBADBAD0CAFEU);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_ASSIGN_WORD_CHECK_BIT)
+{
+  CIEC_LWORD nTestLWord;
+
+  nTestLWord.W<3>() = 0x00FE;
+  nTestLWord.W<2>() = 0xEDFA;
+  nTestLWord.W<1>() = 0xCEC0;
+  nTestLWord.W<0>() = 0xFFEE;
+
+  test4X_0(nTestLWord,60);
+  test4X_0(nTestLWord,56);
+  test4X_F(nTestLWord,52);
+  test4X_E(nTestLWord,48);
+  test4X_E(nTestLWord,44);
+  test4X_D(nTestLWord,40);
+  test4X_F(nTestLWord,36);
+  test4X_A(nTestLWord,32);
+  test4X_C(nTestLWord,28);
+  test4X_E(nTestLWord,24);
+  test4X_C(nTestLWord,20);
+  test4X_0(nTestLWord,16);
+  test4X_F(nTestLWord,12);
+  test4X_F(nTestLWord,8);
+  test4X_E(nTestLWord,4);
+  test4X_E(nTestLWord,0);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_ASSIGN_WORD_CHECK_BYTE)
+{
+  CIEC_LWORD nTestLWord;
+
+  nTestLWord.W<3>() = 0x00FE;
+  nTestLWord.W<2>() = 0xEDFA;
+  nTestLWord.W<1>() = 0xCEC0;
+  nTestLWord.W<0>() = 0xFFEE;
+
+  BOOST_CHECK_EQUAL(nTestLWord.B<7>(), 0x00U);
+  BOOST_CHECK_EQUAL(nTestLWord.B<6>(), 0xFEU);
+  BOOST_CHECK_EQUAL(nTestLWord.B<5>(), 0xEDU);
+  BOOST_CHECK_EQUAL(nTestLWord.B<4>(), 0xFAU);
+  BOOST_CHECK_EQUAL(nTestLWord.B<3>(), 0xCEU);
+  BOOST_CHECK_EQUAL(nTestLWord.B<2>(), 0xC0U);
+  BOOST_CHECK_EQUAL(nTestLWord.B<1>(), 0xFFU);
+  BOOST_CHECK_EQUAL(nTestLWord.B<0>(), 0xEEU);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_ASSIGN_WORD_CHECK_WORD)
+{
+  CIEC_LWORD nTestLWord;
+
+  nTestLWord.W<3>() = 0x00FE;
+  nTestLWord.W<2>() = 0xEDFA;
+  nTestLWord.W<1>() = 0xCEC0;
+  nTestLWord.W<0>() = 0xFFEE;
+
+  BOOST_CHECK_EQUAL(nTestLWord.W<3>(), 0x00FEU);
+  BOOST_CHECK_EQUAL(nTestLWord.W<2>(), 0xEDFAU);
+  BOOST_CHECK_EQUAL(nTestLWord.W<1>(), 0xCEC0U);
+  BOOST_CHECK_EQUAL(nTestLWord.W<0>(), 0xFFEEU);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_ASSIGN_WORD_CHECK_DWORD)
+{
+  CIEC_LWORD nTestLWord;
+
+  nTestLWord.W<3>() = 0x00FE;
+  nTestLWord.W<2>() = 0xEDFA;
+  nTestLWord.W<1>() = 0xCEC0;
+  nTestLWord.W<0>() = 0xFFEE;
+
+  BOOST_CHECK_EQUAL(nTestLWord.D<1>(), 0x00FEEDFAU);
+  BOOST_CHECK_EQUAL(nTestLWord.D<0>(), 0xCEC0FFEEU);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_ASSIGN_WORD_CHECK_LWORD)
+{
+  CIEC_LWORD nTestLWord;
+
+  nTestLWord.W<3>() = 0x00FE;
+  nTestLWord.W<2>() = 0xEDFA;
+  nTestLWord.W<1>() = 0xCEC0;
+  nTestLWord.W<0>() = 0xFFEE;
+
+  BOOST_CHECK_EQUAL(nTestLWord, 0x00FEEDFACEC0FFEEU);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_ASSIGN_DWORD_CHECK_BIT)
+{
+  CIEC_LWORD nTestLWord;
+
+  nTestLWord.D<0>() = 0xADD511FE;
+  nTestLWord.D<1>() = 0xC0CAC01A;
+
+  test4X_C(nTestLWord,60);
+  test4X_0(nTestLWord,56);
+  test4X_C(nTestLWord,52);
+  test4X_A(nTestLWord,48);
+  test4X_C(nTestLWord,44);
+  test4X_0(nTestLWord,40);
+  test4X_1(nTestLWord,36);
+  test4X_A(nTestLWord,32);
+  test4X_A(nTestLWord,28);
+  test4X_D(nTestLWord,24);
+  test4X_D(nTestLWord,20);
+  test4X_5(nTestLWord,16);
+  test4X_1(nTestLWord,12);
+  test4X_1(nTestLWord,8);
+  test4X_F(nTestLWord,4);
+  test4X_E(nTestLWord,0);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_ASSIGN_DWORD_CHECK_BYTE)
+{
+  CIEC_LWORD nTestLWord;
+
+  nTestLWord.D<0>() = 0xADD511FE;
+  nTestLWord.D<1>() = 0xC0CAC01A;
+
+  BOOST_CHECK_EQUAL(nTestLWord.B<7>(), 0xC0U);
+  BOOST_CHECK_EQUAL(nTestLWord.B<6>(), 0xCAU);
+  BOOST_CHECK_EQUAL(nTestLWord.B<5>(), 0xC0U);
+  BOOST_CHECK_EQUAL(nTestLWord.B<4>(), 0x1AU);
+  BOOST_CHECK_EQUAL(nTestLWord.B<3>(), 0xADU);
+  BOOST_CHECK_EQUAL(nTestLWord.B<2>(), 0xD5U);
+  BOOST_CHECK_EQUAL(nTestLWord.B<1>(), 0x11U);
+  BOOST_CHECK_EQUAL(nTestLWord.B<0>(), 0xFEU);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_ASSIGN_DWORD_CHECK_WORD)
+{
+  CIEC_LWORD nTestLWord;
+
+  nTestLWord.D<0>() = 0xADD511FE;
+  nTestLWord.D<1>() = 0xC0CAC01A;
+
+  BOOST_CHECK_EQUAL(nTestLWord.W<3>(), 0xC0CAU);
+  BOOST_CHECK_EQUAL(nTestLWord.W<2>(), 0xC01AU);
+  BOOST_CHECK_EQUAL(nTestLWord.W<1>(), 0xADD5U);
+  BOOST_CHECK_EQUAL(nTestLWord.W<0>(), 0x11FEU);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_ASSIGN_DWORD_CHECK_DWORD)
+{
+  CIEC_LWORD nTestLWord;
+
+  nTestLWord.D<0>() = 0xADD511FE;
+  nTestLWord.D<1>() = 0xC0CAC01A;
+
+  BOOST_CHECK_EQUAL(nTestLWord.D<1>(), 0xC0CAC01AU);
+  BOOST_CHECK_EQUAL(nTestLWord.D<0>(), 0xADD511FEU);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_ASSIGN_DWORD_CHECK_LWORD)
+{
+  CIEC_LWORD nTestLWord;
+
+  nTestLWord.D<0>() = 0xADD511FE;
+  nTestLWord.D<1>() = 0xC0CAC01A;
+
+
+  BOOST_CHECK_EQUAL(nTestLWord, 0xC0CAC01AADD511FEU);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_SETVALUE_DWORD_CHECK_LWORD)
+{
+  CIEC_LWORD nTestLWord;
+  CIEC_DWORD nTestDWord;
+
+  nTestDWord = 0xADD511FE;
+  nTestLWord.D<0>().setValue(nTestDWord);
+
+  nTestDWord = 0xC0CAC01A;
+  nTestLWord.D<1>().setValue(nTestDWord);
+
+
+  BOOST_CHECK_EQUAL(nTestLWord, 0xC0CAC01AADD511FEU);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_SETVALUE_WORD_CHECK_LWORD)
+{
+  CIEC_LWORD nTestLWord;
+  CIEC_DWORD nTestWord;
+
+  nTestWord = 0x11FE;
+  nTestLWord.W<0>().setValue(nTestWord);
+
+  nTestWord = 0xADD5;
+  nTestLWord.W<1>().setValue(nTestWord);
+
+  nTestWord = 0xC01A;
+  nTestLWord.W<2>().setValue(nTestWord);
+
+  nTestWord = 0xC0CA;
+  nTestLWord.W<3>().setValue(nTestWord);
+
+
+  BOOST_CHECK_EQUAL(nTestLWord, 0xC0CAC01AADD511FEU);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_ASSIGN_CHAIN_DWORD_BYTE_CHECK_LWORD)
+{
+  CIEC_LWORD nTestLWord;
+
+  nTestLWord.D<1>().B<3>() = 0xDE;
+  nTestLWord.D<1>().B<2>() = 0xCA;
+  nTestLWord.D<1>().B<1>() = 0xFB;
+  nTestLWord.D<1>().B<0>() = 0xAD;
+  nTestLWord.D<0>().B<3>() = 0xBA;
+  nTestLWord.D<0>().B<2>() = 0xD0;
+  nTestLWord.D<0>().B<1>() = 0xCA;
+  nTestLWord.D<0>().B<0>() = 0xFE;
+
+  BOOST_CHECK_EQUAL(nTestLWord, 0xDECAFBADBAD0CAFEU);
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_ASSIGN_CHAIN_DWORD_WORD_CHECK_LWORD)
+{
+  CIEC_LWORD nTestLWord;
+
+  nTestLWord.D<1>().W<1>() = 0x00FE;
+  nTestLWord.D<1>().W<0>() = 0xEDFA;
+  nTestLWord.D<0>().W<1>() = 0xCEC0;
+  nTestLWord.D<0>().W<0>() = 0xFFEE;
+
+  BOOST_CHECK_EQUAL(nTestLWord, 0x00FEEDFACEC0FFEEU);
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_ASSIGN_CHAIN_DWORD_WORD_BIT_CHECK_LWORD)
+{
+  CIEC_LWORD nTestLWord;
+
+  set4X_C(nTestLWord.D<1>().W<1>(),12);
+  set4X_0(nTestLWord.D<1>().W<1>(),8);
+  set4X_C(nTestLWord.D<1>().W<1>(),4);
+  set4X_A(nTestLWord.D<1>().W<1>(),0);
+  set4X_C(nTestLWord.D<1>().W<0>(),12);
+  set4X_0(nTestLWord.D<1>().W<0>(),8);
+  set4X_1(nTestLWord.D<1>().W<0>(),4);
+  set4X_A(nTestLWord.D<1>().W<0>(),0);
+  set4X_A(nTestLWord.D<0>().W<1>(),12);
+  set4X_D(nTestLWord.D<0>().W<1>(),8);
+  set4X_D(nTestLWord.D<0>().W<1>(),4);
+  set4X_5(nTestLWord.D<0>().W<1>(),0);
+  set4X_1(nTestLWord.D<0>().W<0>(),12);
+  set4X_1(nTestLWord.D<0>().W<0>(),8);
+  set4X_F(nTestLWord.D<0>().W<0>(),4);
+  set4X_E(nTestLWord.D<0>().W<0>(),0);
+
+  BOOST_CHECK_EQUAL(nTestLWord, 0xC0CAC01AADD511FEU);
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_ASSIGN_CHAIN_DWORD_WORD_BYTE_BIT_CHECK_LWORD)
+{
+  CIEC_LWORD nTestLWord;
+
+  set4X_0(nTestLWord.D<1>().W<1>().B<1>(),4);
+  set4X_0(nTestLWord.D<1>().W<1>().B<1>(),0);
+  set4X_F(nTestLWord.D<1>().W<1>().B<0>(),4);
+  set4X_E(nTestLWord.D<1>().W<1>().B<0>(),0);
+  set4X_E(nTestLWord.D<1>().W<0>().B<1>(),4);
+  set4X_D(nTestLWord.D<1>().W<0>().B<1>(),0);
+  set4X_F(nTestLWord.D<1>().W<0>().B<0>(),4);
+  set4X_A(nTestLWord.D<1>().W<0>().B<0>(),0);
+  set4X_C(nTestLWord.D<0>().W<1>().B<1>(),4);
+  set4X_E(nTestLWord.D<0>().W<1>().B<1>(),0);
+  set4X_C(nTestLWord.D<0>().W<1>().B<0>(),4);
+  set4X_0(nTestLWord.D<0>().W<1>().B<0>(),0);
+  set4X_F(nTestLWord.D<0>().W<0>().B<1>(),4);
+  set4X_F(nTestLWord.D<0>().W<0>().B<1>(),0);
+  set4X_E(nTestLWord.D<0>().W<0>().B<0>(),4);
+  set4X_E(nTestLWord.D<0>().W<0>().B<0>(),0);
+
+  BOOST_CHECK_EQUAL(nTestLWord, 0x00FEEDFACEC0FFEEU);
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_ASSIGN_CHECK_CHAIN_LWORD_DWORD_WORD)
+{
+
+  CIEC_LWORD nTestLWord;
+
+  nTestLWord = 0x00FEEDFACEC0FFEEU;
+
+  BOOST_CHECK_EQUAL(nTestLWord.D<1>().W<1>(), 0x00FEU);
+  BOOST_CHECK_EQUAL(nTestLWord.D<1>().W<0>(), 0xEDFAU);
+  BOOST_CHECK_EQUAL(nTestLWord.D<0>().W<1>(), 0xCEC0U);
+  BOOST_CHECK_EQUAL(nTestLWord.D<0>().W<0>(), 0xFFEEU);
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_ASSIGN_CHECK_CHAIN_LWORD_DWORD_BYTE)
+{
+
+  CIEC_LWORD nTestLWord;
+
+  nTestLWord = 0x00FEEDFACEC0FFEEU;
+
+  BOOST_CHECK_EQUAL(nTestLWord.D<1>().B<3>(), 0x00U);
+  BOOST_CHECK_EQUAL(nTestLWord.D<1>().B<2>(), 0xFEU);
+  BOOST_CHECK_EQUAL(nTestLWord.D<1>().B<1>(), 0xEDU);
+  BOOST_CHECK_EQUAL(nTestLWord.D<1>().B<0>(), 0xFAU);
+  BOOST_CHECK_EQUAL(nTestLWord.D<0>().B<3>(), 0xCEU);
+  BOOST_CHECK_EQUAL(nTestLWord.D<0>().B<2>(), 0xC0U);
+  BOOST_CHECK_EQUAL(nTestLWord.D<0>().B<1>(), 0xFFU);
+  BOOST_CHECK_EQUAL(nTestLWord.D<0>().B<0>(), 0xEEU);
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_ASSIGN_CHECK_CHAIN_LWORD_DWORD_BIT)
+{
+
+  CIEC_LWORD nTestLWord;
+
+  nTestLWord = 0x00FEEDFACEC0FFEEU;
+
+  test4X_0(nTestLWord.D<1>(),28);
+  test4X_0(nTestLWord.D<1>(),24);
+  test4X_F(nTestLWord.D<1>(),20);
+  test4X_E(nTestLWord.D<1>(),16);
+  test4X_E(nTestLWord.D<1>(),12);
+  test4X_D(nTestLWord.D<1>(),8);
+  test4X_F(nTestLWord.D<1>(),4);
+  test4X_A(nTestLWord.D<1>(),0);
+  test4X_C(nTestLWord.D<0>(),28);
+  test4X_E(nTestLWord.D<0>(),24);
+  test4X_C(nTestLWord.D<0>(),20);
+  test4X_0(nTestLWord.D<0>(),16);
+  test4X_F(nTestLWord.D<0>(),12);
+  test4X_F(nTestLWord.D<0>(),8);
+  test4X_E(nTestLWord.D<0>(),4);
+  test4X_E(nTestLWord.D<0>(),0);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_ASSIGN_CHECK_CHAIN_LWORD_DWORD_WORD_BIT)
+{
+
+  CIEC_LWORD nTestLWord;
+
+  nTestLWord = 0x00FEEDFACEC0FFEEU;
+
+  test4X_0(nTestLWord.D<1>().W<1>(),12);
+  test4X_0(nTestLWord.D<1>().W<1>(),8);
+  test4X_F(nTestLWord.D<1>().W<1>(),4);
+  test4X_E(nTestLWord.D<1>().W<1>(),0);
+  test4X_E(nTestLWord.D<1>().W<0>(),12);
+  test4X_D(nTestLWord.D<1>().W<0>(),8);
+  test4X_F(nTestLWord.D<1>().W<0>(),4);
+  test4X_A(nTestLWord.D<1>().W<0>(),0);
+  test4X_C(nTestLWord.D<0>().W<1>(),12);
+  test4X_E(nTestLWord.D<0>().W<1>(),8);
+  test4X_C(nTestLWord.D<0>().W<1>(),4);
+  test4X_0(nTestLWord.D<0>().W<1>(),0);
+  test4X_F(nTestLWord.D<0>().W<0>(),12);
+  test4X_F(nTestLWord.D<0>().W<0>(),8);
+  test4X_E(nTestLWord.D<0>().W<0>(),4);
+  test4X_E(nTestLWord.D<0>().W<0>(),0);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_ASSIGN_CHECK_CHAIN_LWORD_DWORD_WORD_BYTE_BIT)
+{
+
+  CIEC_LWORD nTestLWord;
+
+  nTestLWord = 0x00FEEDFACEC0FFEEU;
+
+  test4X_0(nTestLWord.D<1>().W<1>().B<1>(),4);
+  test4X_0(nTestLWord.D<1>().W<1>().B<1>(),0);
+  test4X_F(nTestLWord.D<1>().W<1>().B<0>(),4);
+  test4X_E(nTestLWord.D<1>().W<1>().B<0>(),0);
+  test4X_E(nTestLWord.D<1>().W<0>().B<1>(),4);
+  test4X_D(nTestLWord.D<1>().W<0>().B<1>(),0);
+  test4X_F(nTestLWord.D<1>().W<0>().B<0>(),4);
+  test4X_A(nTestLWord.D<1>().W<0>().B<0>(),0);
+  test4X_C(nTestLWord.D<0>().W<1>().B<1>(),4);
+  test4X_E(nTestLWord.D<0>().W<1>().B<1>(),0);
+  test4X_C(nTestLWord.D<0>().W<1>().B<0>(),4);
+  test4X_0(nTestLWord.D<0>().W<1>().B<0>(),0);
+  test4X_F(nTestLWord.D<0>().W<0>().B<1>(),4);
+  test4X_F(nTestLWord.D<0>().W<0>().B<1>(),0);
+  test4X_E(nTestLWord.D<0>().W<0>().B<0>(),4);
+  test4X_E(nTestLWord.D<0>().W<0>().B<0>(),0);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_LWORD_ASSIGN_CHECK_CHAIN_LWORD_DWORD_BYTE_BIT)
+{
+
+  CIEC_LWORD nTestLWord;
+
+  nTestLWord = 0x00FEEDFACEC0FFEEU;
+
+  BOOST_CHECK_EQUAL(nTestLWord.D<1>().B<3>(), 0x00U);
+  BOOST_CHECK_EQUAL(nTestLWord.D<1>().B<2>(), 0xFEU);
+  BOOST_CHECK_EQUAL(nTestLWord.D<1>().B<1>(), 0xEDU);
+  BOOST_CHECK_EQUAL(nTestLWord.D<1>().B<0>(), 0xFAU);
+  BOOST_CHECK_EQUAL(nTestLWord.D<0>().B<3>(), 0xCEU);
+  BOOST_CHECK_EQUAL(nTestLWord.D<0>().B<2>(), 0xC0U);
+  BOOST_CHECK_EQUAL(nTestLWord.D<0>().B<1>(), 0xFFU);
+  BOOST_CHECK_EQUAL(nTestLWord.D<0>().B<0>(), 0xEEU);
+
+}
+
+#endif //#ifdef FORTE_USE_64BIT_DATATYPES
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/tests/core/datatypes/CIEC_PARTIAL/CIEC_PARTIAL_test.h b/tests/core/datatypes/CIEC_PARTIAL/CIEC_PARTIAL_test.h
new file mode 100644
index 000000000..c478ec7e6
--- /dev/null
+++ b/tests/core/datatypes/CIEC_PARTIAL/CIEC_PARTIAL_test.h
@@ -0,0 +1,65 @@
+/*******************************************************************************
+ * Copyright (c) 2011 - 2012 ACIN, nxtControl, 2018 TU Vienna/ACIN
+ *               2020 Johannes Kepler University Linz
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *   Martin Melik Merkumians, Ingo Hegny, Alois Zoitl, Stanislav Meduna - initial API and implementation and/or initial documentation
+ *   Ernst Blecha - Adds partial access tests
+ *******************************************************************************/
+
+#ifndef CIEC_ANY_BIT_PARTIAL_TEST
+#define CIEC_ANY_BIT_PARTIAL_TEST
+
+#define test4X(var, offset, b3, b2, b1, b0) \
+  BOOST_CHECK_EQUAL(var.X<0+offset>(),b0);\
+  BOOST_CHECK_EQUAL(var.X<1+offset>(),b1);\
+  BOOST_CHECK_EQUAL(var.X<2+offset>(),b2);\
+  BOOST_CHECK_EQUAL(var.X<3+offset>(),b3);
+
+#define test4X_0(var, offset) test4X(var, offset, 0, 0, 0, 0)
+#define test4X_1(var, offset) test4X(var, offset, 0, 0, 0, 1)
+#define test4X_2(var, offset) test4X(var, offset, 0, 0, 1, 0)
+#define test4X_3(var, offset) test4X(var, offset, 0, 0, 1, 1)
+#define test4X_4(var, offset) test4X(var, offset, 0, 1, 0, 0)
+#define test4X_5(var, offset) test4X(var, offset, 0, 1, 0, 1)
+#define test4X_6(var, offset) test4X(var, offset, 0, 1, 1, 0)
+#define test4X_7(var, offset) test4X(var, offset, 0, 1, 1, 1)
+#define test4X_8(var, offset) test4X(var, offset, 1, 0, 0, 0)
+#define test4X_9(var, offset) test4X(var, offset, 1, 0, 0, 1)
+#define test4X_A(var, offset) test4X(var, offset, 1, 0, 1, 0)
+#define test4X_B(var, offset) test4X(var, offset, 1, 0, 1, 1)
+#define test4X_C(var, offset) test4X(var, offset, 1, 1, 0, 0)
+#define test4X_D(var, offset) test4X(var, offset, 1, 1, 0, 1)
+#define test4X_E(var, offset) test4X(var, offset, 1, 1, 1, 0)
+#define test4X_F(var, offset) test4X(var, offset, 1, 1, 1, 1)
+
+
+#define set4X(var, offset, b3, b2, b1, b0) \
+  var.X<0+offset>()=b0;\
+  var.X<1+offset>()=b1;\
+  var.X<2+offset>()=b2;\
+  var.X<3+offset>()=b3;
+
+#define set4X_0(var, offset) set4X(var, offset, 0, 0, 0, 0)
+#define set4X_1(var, offset) set4X(var, offset, 0, 0, 0, 1)
+#define set4X_2(var, offset) set4X(var, offset, 0, 0, 1, 0)
+#define set4X_3(var, offset) set4X(var, offset, 0, 0, 1, 1)
+#define set4X_4(var, offset) set4X(var, offset, 0, 1, 0, 0)
+#define set4X_5(var, offset) set4X(var, offset, 0, 1, 0, 1)
+#define set4X_6(var, offset) set4X(var, offset, 0, 1, 1, 0)
+#define set4X_7(var, offset) set4X(var, offset, 0, 1, 1, 1)
+#define set4X_8(var, offset) set4X(var, offset, 1, 0, 0, 0)
+#define set4X_9(var, offset) set4X(var, offset, 1, 0, 0, 1)
+#define set4X_A(var, offset) set4X(var, offset, 1, 0, 1, 0)
+#define set4X_B(var, offset) set4X(var, offset, 1, 0, 1, 1)
+#define set4X_C(var, offset) set4X(var, offset, 1, 1, 0, 0)
+#define set4X_D(var, offset) set4X(var, offset, 1, 1, 0, 1)
+#define set4X_E(var, offset) set4X(var, offset, 1, 1, 1, 0)
+#define set4X_F(var, offset) set4X(var, offset, 1, 1, 1, 1)
+
+#endif
diff --git a/tests/core/datatypes/CIEC_PARTIAL/CIEC_WORD_PARTIAL_test.cpp b/tests/core/datatypes/CIEC_PARTIAL/CIEC_WORD_PARTIAL_test.cpp
new file mode 100644
index 000000000..0c4ae5408
--- /dev/null
+++ b/tests/core/datatypes/CIEC_PARTIAL/CIEC_WORD_PARTIAL_test.cpp
@@ -0,0 +1,246 @@
+/*******************************************************************************
+ * Copyright (c) 2011 - 2012 ACIN, nxtControl, 2018 TU Vienna/ACIN
+ *               2020 Johannes Kepler University Linz
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *   Martin Melik Merkumians, Ingo Hegny, Alois Zoitl, Stanislav Meduna - initial API and implementation and/or initial documentation
+ *   Ernst Blecha - Adds partial access tests
+ *******************************************************************************/
+
+#include <boost/test/unit_test.hpp>
+
+/*#ifdef FORTE_USE_REAL_DATATYPE
+  #include <boost/test/floating_point_comparison.hpp>
+
+  #include "../../../src/core/datatypes/forte_real.h"
+#endif //FORTE_USE_REAL_DATATYPE*/
+
+//BOOLEAN
+#include "../../../src/core/datatypes/forte_bool.h"
+//BIT-Datatypes
+#include "../../../src/core/datatypes/forte_byte.h"
+#include "../../../src/core/datatypes/forte_word.h"
+
+#include "CIEC_PARTIAL_test.h"
+
+using namespace boost::unit_test;
+
+BOOST_AUTO_TEST_SUITE(CIEC_ANY_BIT_PARTIAL)
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_WORD_INITVALUES_CHECK_BIT)
+{
+  CIEC_WORD nTestWord;
+
+  test4X_0(nTestWord, 12)
+  test4X_0(nTestWord, 8)
+  test4X_0(nTestWord, 4)
+  test4X_0(nTestWord, 0)
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_WORD_INITVALUES_CHECK_BYTE)
+{
+  CIEC_WORD nTestWord;
+
+  BOOST_CHECK_EQUAL(nTestWord.B<0>(),0);
+  BOOST_CHECK_EQUAL(nTestWord.B<1>(),0);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_WORD_VALUE_CHECK_WORD)
+{
+  CIEC_WORD nTestWord;
+
+  nTestWord=0xBABE;
+
+  BOOST_CHECK_EQUAL(nTestWord, 0xBABE);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_WORD_VALUE_CHECK_BYTE)
+{
+  CIEC_WORD nTestWord;
+
+  nTestWord=0xBABE;
+
+  BOOST_CHECK_EQUAL(nTestWord.B<0>(), 0xBE);
+  BOOST_CHECK_EQUAL(nTestWord.B<1>(), 0xBA);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_WORD_VALUE_CHECK_BIT)
+{
+  CIEC_WORD nTestWord;
+
+  nTestWord=0xBABE;
+
+  test4X_B(nTestWord, 12)
+  test4X_A(nTestWord, 8)
+  test4X_B(nTestWord, 4)
+  test4X_E(nTestWord, 0)
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_WORD_ASSIGN_BIT_CHECK_BIT)
+{
+  CIEC_WORD nTestWord;
+
+  set4X_F(nTestWord,12);
+  set4X_0(nTestWord,8);
+  set4X_0(nTestWord,4);
+  set4X_D(nTestWord,0);
+
+  test4X_F(nTestWord,12);
+  test4X_0(nTestWord,8);
+  test4X_0(nTestWord,4);
+  test4X_D(nTestWord,0);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_WORD_ASSIGN_BIT_CHECK_BYTE)
+{
+  CIEC_WORD nTestWord;
+
+  set4X_F(nTestWord,12);
+  set4X_0(nTestWord,8);
+  set4X_0(nTestWord,4);
+  set4X_D(nTestWord,0);
+
+  BOOST_CHECK_EQUAL(nTestWord.B<1>(), 0xF0U);
+  BOOST_CHECK_EQUAL(nTestWord.B<0>(), 0x0DU);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_WORD_ASSIGN_BIT_CHECK_WORD)
+{
+  CIEC_WORD nTestWord;
+
+  set4X_F(nTestWord,12);
+  set4X_0(nTestWord,8);
+  set4X_0(nTestWord,4);
+  set4X_D(nTestWord,0);
+
+  BOOST_CHECK_EQUAL(nTestWord, 0xF00DU);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_WORD_ASSIGN_BYTE_CHECK_BIT)
+{
+  CIEC_WORD nTestWord;
+
+  nTestWord.B<1>() = 0xCA;
+  nTestWord.B<0>() = 0xFE;
+
+  test4X_C(nTestWord,12);
+  test4X_A(nTestWord,8);
+  test4X_F(nTestWord,4);
+  test4X_E(nTestWord,0);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_WORD_ASSIGN_BYTE_CHECK_BYTE)
+{
+  CIEC_WORD nTestWord;
+
+  nTestWord.B<1>() = 0xCA;
+  nTestWord.B<0>() = 0xFE;
+
+  BOOST_CHECK_EQUAL(nTestWord.B<1>(), 0xCAU);
+  BOOST_CHECK_EQUAL(nTestWord.B<0>(), 0xFEU);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_WORD_ASSIGN_BYTE_CHECK_WORD)
+{
+  CIEC_WORD nTestWord;
+
+  nTestWord.B<1>() = 0xCA;
+  nTestWord.B<0>() = 0xFE;
+
+  BOOST_CHECK_EQUAL(nTestWord, 0xCAFEU);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_WORD_ASSIGN_WORD_CHECK_BIT)
+{
+  CIEC_WORD nTestWord;
+
+  nTestWord = 0xFFEE;
+
+  test4X_F(nTestWord,12);
+  test4X_F(nTestWord,8);
+  test4X_E(nTestWord,4);
+  test4X_E(nTestWord,0);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_WORD_ASSIGN_WORD_CHECK_BYTE)
+{
+  CIEC_WORD nTestWord;
+
+  nTestWord = 0xFFEE;
+
+  BOOST_CHECK_EQUAL(nTestWord.B<1>(), 0xFFU);
+  BOOST_CHECK_EQUAL(nTestWord.B<0>(), 0xEEU);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_WORD_ASSIGN_WORD_CHECK_WORD)
+{
+  CIEC_WORD nTestWord;
+
+  nTestWord = 0xFFEE;
+
+  BOOST_CHECK_EQUAL(nTestWord, 0xFFEEU);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_WORD_ASSIGN_CHAIN_BYTE_BIT_CHECK_BIT)
+{
+  CIEC_WORD nTestWord;
+
+  set4X_1(nTestWord,12);
+  set4X_1(nTestWord,8);
+  set4X_F(nTestWord,4);
+  set4X_E(nTestWord,0);
+
+  test4X_1(nTestWord,12);
+  test4X_1(nTestWord,8);
+  test4X_F(nTestWord,4);
+  test4X_E(nTestWord,0);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_WORD_ASSIGN_CHAIN_BYTE_BIT_CHECK_BYTE)
+{
+  CIEC_WORD nTestWord;
+
+  set4X_1(nTestWord,12);
+  set4X_1(nTestWord,8);
+  set4X_F(nTestWord,4);
+  set4X_E(nTestWord,0);
+
+  BOOST_CHECK_EQUAL(nTestWord.B<1>(), 0x11U);
+  BOOST_CHECK_EQUAL(nTestWord.B<0>(), 0xFEU);
+
+}
+
+BOOST_AUTO_TEST_CASE(PARTIAL_ACCESS_WORD_ASSIGN_CHAIN_BYTE_BIT_CHECK_WORD)
+{
+  CIEC_WORD nTestWord;
+
+  set4X_1(nTestWord,12);
+  set4X_1(nTestWord,8);
+  set4X_F(nTestWord,4);
+  set4X_E(nTestWord,0);
+
+  BOOST_CHECK_EQUAL(nTestWord, 0x11FEU);
+
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/tests/core/datatypes/CIEC_PARTIAL/CMakeLists.txt b/tests/core/datatypes/CIEC_PARTIAL/CMakeLists.txt
new file mode 100644
index 000000000..bf482939e
--- /dev/null
+++ b/tests/core/datatypes/CIEC_PARTIAL/CMakeLists.txt
@@ -0,0 +1,26 @@
+#*******************************************************************************
+# Copyright (c) 2011 - 2014 nxtControl, ACIN, fortiss GmbH, Profactor GmbH
+#               2020 Johannes Kepler University Linz
+# This program and the accompanying materials are made available under the
+# terms of the Eclipse Public License 2.0 which is available at
+# http://www.eclipse.org/legal/epl-2.0.
+#
+# SPDX-License-Identifier: EPL-2.0
+# 
+# Contributors:
+#    Stanislav Meduna, Ingo Hegny, Alois Zoitl, Monika Wenger, Matthias Plasch  - initial API and implementation and/or initial documentation
+#    Ernst Blecha - add multibit partial access
+# *******************************************************************************/
+
+#SET(SOURCE_GROUP ${SOURCE_GROUP}\\core)
+
+  forte_test_add_inc_directories(${CMAKE_CURRENT_SOURCE_DIR})
+  
+#BIT-Datatypes  
+  forte_test_add_sourcefile_cpp(CIEC_BYTE_PARTIAL_test.cpp)
+  forte_test_add_sourcefile_cpp(CIEC_WORD_PARTIAL_test.cpp)
+  forte_test_add_sourcefile_cpp(CIEC_DWORD_PARTIAL_test.cpp)
+IF (FORTE_USE_64BIT_DATATYPES)
+  forte_test_add_sourcefile_cpp(CIEC_LWORD_PARTIAL_test.cpp)
+ENDIF (FORTE_USE_64BIT_DATATYPES) 
+
diff --git a/tests/core/datatypes/CMakeLists.txt b/tests/core/datatypes/CMakeLists.txt
index 45e3f7778..9d1aeb019 100644
--- a/tests/core/datatypes/CMakeLists.txt
+++ b/tests/core/datatypes/CMakeLists.txt
@@ -1,5 +1,6 @@
 #*******************************************************************************
 # Copyright (c) 2011 - 2014 nxtControl, ACIN, fortiss GmbH, Profactor GmbH
+#               2020 Johannes Kepler University Linz
 # This program and the accompanying materials are made available under the
 # terms of the Eclipse Public License 2.0 which is available at
 # http://www.eclipse.org/legal/epl-2.0.
@@ -8,6 +9,7 @@
 # 
 # Contributors:
 #    Stanislav Meduna, Ingo Hegny, Alois Zoitl, Monika Wenger, Matthias Plasch  - initial API and implementation and/or initial documentation
+#    Ernst Blecha - add multibit partial access
 # *******************************************************************************/
 
 #SET(SOURCE_GROUP ${SOURCE_GROUP}\\core)
@@ -35,6 +37,7 @@ IF (FORTE_USE_64BIT_DATATYPES)
   forte_test_add_sourcefile_cpp(CIEC_LWORD_test.cpp)
   forte_test_add_sourcefile_cpp(CIEC_LWORD_CASTS_test.cpp)
 ENDIF (FORTE_USE_64BIT_DATATYPES) 
+  forte_test_add_subdirectory(CIEC_PARTIAL)
   
 #INT-Datatypes
   forte_test_add_sourcefile_cpp(CIEC_SINT_test.cpp)
@@ -82,4 +85,4 @@ ENDIF(FORTE_SUPPORT_ARRAYS)
   
   forte_test_add_sourcefile_cpp(CIEC_STRUCT_test.cpp)
  
- forte_test_add_subdirectory(convert)
-\ No newline at end of file
+ forte_test_add_subdirectory(convert)
author	Ernst Blecha	2020-01-08 17:18:02 +0000
committer	Ernst Blecha	2020-01-27 15:51:50 +0000
commit	5bb1cfed4d722ad245deca0d83fca88f024c93b4 (patch)
tree	4e88cb6176d065eb199176143329ac87a324b852
parent	f435b4e3b34e2a240ef48e52f2c06cc890a5204c (diff)
download	org.eclipse.4diac.forte-5bb1cfed4d722ad245deca0d83fca88f024c93b4.tar.gz org.eclipse.4diac.forte-5bb1cfed4d722ad245deca0d83fca88f024c93b4.tar.xz org.eclipse.4diac.forte-5bb1cfed4d722ad245deca0d83fca88f024c93b4.zip