diff --git a/src/main/java/org/openepics/names/service/StructuresService.java b/src/main/java/org/openepics/names/service/StructuresService.java
index d598c132b33bcb21a31144046a1698c60fcc95ce..cfe87fc9f9fa98df5ef953d99173ff6e552efff1 100644
--- a/src/main/java/org/openepics/names/service/StructuresService.java
+++ b/src/main/java/org/openepics/names/service/StructuresService.java
@@ -618,7 +618,7 @@ public class StructuresService {
         //             relative other data
 
         // validate input
-        ValidateUtil.validateStructureElementInputCreate(structureElement);
+        ValidateUtil.validateStructureElementInputCreate(structureElement, namingConvention);
 
         // validate data
         ValidateUtil.validateStructureElementDataCreate(structureElement, namingConvention, holderRepositories, holder);
@@ -647,7 +647,7 @@ public class StructuresService {
         //             relative other data
 
         // validate input
-        ValidateUtil.validateStructureElementInputUpdate(structureElement);
+        ValidateUtil.validateStructureElementInputUpdate(structureElement, namingConvention);
 
         // validate data
         ValidateUtil.validateStructureElementDataUpdate(structureElement, namingConvention, holderRepositories, holder);
@@ -676,7 +676,7 @@ public class StructuresService {
         //             relative other data
 
         // validate input
-        ValidateUtil.validateStructureElementInputDelete(structureElement);
+        ValidateUtil.validateStructureElementInputDelete(structureElement, namingConvention);
 
         // validate data
         ValidateUtil.validateStructureElementDataDelete(structureElement, namingConvention, holderRepositories, holder);
@@ -705,7 +705,7 @@ public class StructuresService {
         //             relative other data
 
         // validate input
-        ValidateUtil.validateStructureElementInputApprove(structureElement);
+        ValidateUtil.validateStructureElementInputApprove(structureElement, namingConvention);
 
         // validate data
         ValidateUtil.validateStructureElementDataApprove(structureElement, namingConvention, holderRepositories, holder);
@@ -734,7 +734,7 @@ public class StructuresService {
         //             relative other data
 
         // validate input
-        ValidateUtil.validateStructureElementInputCancel(structureElement);
+        ValidateUtil.validateStructureElementInputCancel(structureElement, namingConvention);
 
         // validate data
         ValidateUtil.validateStructureElementDataCancel(structureElement, namingConvention, holderRepositories, holder);
@@ -763,7 +763,7 @@ public class StructuresService {
         //             relative other data
 
         // validate input
-        ValidateUtil.validateStructureElementInputReject(structureElement);
+        ValidateUtil.validateStructureElementInputReject(structureElement, namingConvention);
 
         // validate data
         ValidateUtil.validateStructureElementDataReject(structureElement, namingConvention, holderRepositories, holder);
diff --git a/src/main/java/org/openepics/names/util/EssNamingConvention.java b/src/main/java/org/openepics/names/util/EssNamingConvention.java
index ffd39069cbb9f7b1adff96397e622016d6b48875..d1b8aba11db3747a3d7045026b2c90fdaac9575d 100644
--- a/src/main/java/org/openepics/names/util/EssNamingConvention.java
+++ b/src/main/java/org/openepics/names/util/EssNamingConvention.java
@@ -19,6 +19,7 @@
 package org.openepics.names.util;
 
 import org.apache.commons.lang3.StringUtils;
+import org.openepics.names.rest.beans.Type;
 
 /**
  * A naming convention definition used by ESS.
@@ -57,6 +58,16 @@ public class EssNamingConvention implements NamingConvention {
     private static final String MNEMONIC_NUMERIC              = "^[0-9]+$";
     private static final String MNEMONIC_NUMERIC_ZERO         = "^[0]+$";
 
+    @Override
+    public String equivalenceClassRepresentative(String name) {
+        return name != null
+                ? name.toUpperCase()
+                        .replaceAll("(?<=[A-Za-z])0+", "")
+                        .replace('I', '1').replace('L', '1').replace('O', '0')
+                        .replaceAll("(?<!\\d)0+(?=\\d)", "")
+                : null;
+    }
+
     @Override
     public boolean isInstanceIndexValid(String conventionName) {
         // not override ruleset for instanceIndex
@@ -132,16 +143,6 @@ public class EssNamingConvention implements NamingConvention {
         }
     }
 
-    @Override
-    public String equivalenceClassRepresentative(String name) {
-        return name != null
-                ? name.toUpperCase()
-                        .replaceAll("(?<=[A-Za-z])0+", "")
-                        .replace('I', '1').replace('L', '1').replace('O', '0')
-                        .replaceAll("(?<!\\d)0+(?=\\d)", "")
-                : null;
-    }
-
     @Override
     public boolean isMnemonicPathValid(String mnemonicPath) {
         // note
@@ -170,4 +171,80 @@ public class EssNamingConvention implements NamingConvention {
         return false;
     }
 
+	@Override
+	public boolean isMnemonicRequired(Type type) {
+		if (type != null
+				&& (Type.SYSTEM.equals(type)
+						|| Type.SUBSYSTEM.equals(type)
+						|| Type.DISCIPLINE.equals(type)
+						|| Type.DEVICETYPE.equals(type))) {
+			return true;
+		}
+		return false;
+	}
+
+	@Override
+	public MnemonicValidation validateMnemonic(Type type, String mnemonic) {
+        // mnemonic validation for system and device structure elements
+        // rules for characters
+        //     depends on system/device structure, required or not
+        //     alphanumeric - MNEMONIC_ALPHANUMERIC
+        //     length
+        //         system structure
+        //             system group  - 0-6 characters, not required
+        //             system        - 1-8 characters
+        //             sub system    - 1-8 characters
+        //         device structure
+        //             discipline    - 1-6 characters
+        //             device group  - not required
+        //             device type   - 1-6 characters
+        //
+        // validation for last element in structure / path
+        // accelerator as system
+        //     system group as system, not required
+
+		if (type != null) {
+	        boolean empty = StringUtils.isEmpty(mnemonic);
+	        int length = empty ? 0 : mnemonic.length();
+	        boolean length1to6 = (length >= 1) && (length <= 6);
+	        boolean length1to8 = (length >= 1) && (length <= 8);
+	        boolean matchMnemonic = !empty && mnemonic.matches(MNEMONIC_ALPHANUMERIC);
+
+	        MnemonicValidation result = MnemonicValidation.VALID;
+
+			if (Type.SYSTEMGROUP.equals(type)) {
+                if (empty) {
+                    result = MnemonicValidation.VALID;
+                } else if (!length1to6) {
+                    result = MnemonicValidation.TOO_LONG;
+                } else if (!matchMnemonic) {
+                    result = MnemonicValidation.NON_ACCEPTABLE_CHARS;
+                }
+			} else if (Type.SYSTEM.equals(type) || Type.SUBSYSTEM.equals(type)) {
+                if (empty) {
+                    result = MnemonicValidation.EMPTY;
+                } else if (!length1to8) {
+                    result = MnemonicValidation.TOO_LONG;
+                } else if (!matchMnemonic) {
+                    result = MnemonicValidation.NON_ACCEPTABLE_CHARS;
+                }
+			} else if (Type.DISCIPLINE.equals(type) || Type.DEVICETYPE.equals(type)) {
+                if (empty) {
+                    result = MnemonicValidation.EMPTY;
+                } else if (!length1to6) {
+                    result = MnemonicValidation.TOO_LONG;
+                } else if (!matchMnemonic) {
+                    result = MnemonicValidation.NON_ACCEPTABLE_CHARS;
+                }
+			} else if (Type.DEVICEGROUP.equals(type)) {
+                if (!empty) {
+                    result = MnemonicValidation.NON_ACCEPTABLE_CHARS;
+                }
+			}
+
+			return result;
+		}
+		return null;
+	}
+
 }
diff --git a/src/main/java/org/openepics/names/util/MnemonicValidation.java b/src/main/java/org/openepics/names/util/MnemonicValidation.java
new file mode 100644
index 0000000000000000000000000000000000000000..edf6ffba388ae10cff4aef8e1996a0b6f1d4c4e0
--- /dev/null
+++ b/src/main/java/org/openepics/names/util/MnemonicValidation.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2018 European Spallation Source ERIC.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+
+package org.openepics.names.util;
+
+/**
+ *
+ * Type of the mnemonic validation error specifying whether it too long or uses non-acceptable characters.
+ *
+ * @author banafshehhajinasab
+ */
+public enum MnemonicValidation {
+
+   TOO_LONG, NON_ACCEPTABLE_CHARS, VALID, EMPTY;
+
+}
diff --git a/src/main/java/org/openepics/names/util/NamingConvention.java b/src/main/java/org/openepics/names/util/NamingConvention.java
index b99c15e601070a576f1510d82607a81e2c37423d..db22c655601c023a1eec25736671100446241634 100644
--- a/src/main/java/org/openepics/names/util/NamingConvention.java
+++ b/src/main/java/org/openepics/names/util/NamingConvention.java
@@ -18,6 +18,8 @@
 
 package org.openepics.names.util;
 
+import org.openepics.names.rest.beans.Type;
+
 /**
  * An interface defining the naming convention to be used by the Naming application.
  * It includes:
@@ -111,6 +113,15 @@ package org.openepics.names.util;
  */
 public interface NamingConvention {
 
+    /**
+     * Return equivalence class representative for given name. This is used to ensure uniqueness of names
+     * when treating similar looking names, e.g. 0 vs. O, 1 vs. l treated as as equal.
+     *
+     * @param name      name of which to determine the equivalence class representative
+     * @return          equivalence class representative for given name
+     */
+    String equivalenceClassRepresentative(String name);
+
     /**
      * Return if the convention name's instance index is valid according to convention rules,
      * in the context of system structure and device structure.
@@ -132,15 +143,6 @@ public interface NamingConvention {
      */
     boolean isInstanceIndexValid(String conventionName, boolean overrideRuleset);
 
-    /**
-     * Return equivalence class representative for given name. This is used to ensure uniqueness of names
-     * when treating similar looking names, e.g. 0 vs. O, 1 vs. l treated as as equal.
-     *
-     * @param name      name of which to determine the equivalence class representative
-     * @return          equivalence class representative for given name
-     */
-    String equivalenceClassRepresentative(String name);
-
     /**
      * Return if mnemonic path is valid within the application according to the convention rules.
      *
@@ -149,4 +151,21 @@ public interface NamingConvention {
      */
     boolean isMnemonicPathValid(String mnemonicPath);
 
+    /**
+     * Return if the mnemonic is required or if it can be <tt>null</tt>, i.e. mnemonic not part of the name.
+     *
+     * @param type type
+     * @return                  <tt>true</tt> if the mnemonic is required or if it can be <tt>null</tt>, i.e. mnemonic
+     */
+    boolean isMnemonicRequired(Type type);
+
+    /**
+     * Return validation for given type and mnemonic according to convention rules.
+     *
+     * @param type              type specifying whether mnemonic belongs to the system structure or the device structure
+     * @param mnemonic          mnemonic to be tested
+     * @return                  validation for given mnemonic path and type, according to convention rules
+     */
+    MnemonicValidation validateMnemonic(Type type, String mnemonic);
+
 }
diff --git a/src/main/java/org/openepics/names/util/ValidateUtil.java b/src/main/java/org/openepics/names/util/ValidateUtil.java
index 3ecc043820d23fa096119b230197da07bd7abea0..460d40c3d6787d068d35f7c18578566588794705 100644
--- a/src/main/java/org/openepics/names/util/ValidateUtil.java
+++ b/src/main/java/org/openepics/names/util/ValidateUtil.java
@@ -717,8 +717,8 @@ public class ValidateUtil {
      *
      * @param structureElement structure element
      */
-    public static void validateStructureElementInputCreate(StructureElement structureElement) {
-        validateStructureElementInput(structureElement, StructureChoice.CREATE);
+    public static void validateStructureElementInputCreate(StructureElement structureElement, EssNamingConvention namingConvention) {
+        validateStructureElementInput(structureElement, namingConvention, StructureChoice.CREATE);
     }
 
     /**
@@ -726,8 +726,8 @@ public class ValidateUtil {
      *
      * @param structureElement structure element
      */
-    public static void validateStructureElementInputUpdate(StructureElement structureElement) {
-        validateStructureElementInput(structureElement, StructureChoice.UPDATE);
+    public static void validateStructureElementInputUpdate(StructureElement structureElement, EssNamingConvention namingConvention) {
+        validateStructureElementInput(structureElement, namingConvention, StructureChoice.UPDATE);
     }
 
     /**
@@ -735,8 +735,8 @@ public class ValidateUtil {
      *
      * @param structureElement structure element
      */
-    public static void validateStructureElementInputDelete(StructureElement structureElement) {
-        validateStructureElementInput(structureElement, StructureChoice.DELETE);
+    public static void validateStructureElementInputDelete(StructureElement structureElement, EssNamingConvention namingConvention) {
+        validateStructureElementInput(structureElement, namingConvention, StructureChoice.DELETE);
     }
 
     /**
@@ -744,8 +744,8 @@ public class ValidateUtil {
      *
      * @param structureElement structure element
      */
-    public static void validateStructureElementInputApprove(StructureElement structureElement) {
-        validateStructureElementInput(structureElement, StructureChoice.APPROVE);
+    public static void validateStructureElementInputApprove(StructureElement structureElement, EssNamingConvention namingConvention) {
+        validateStructureElementInput(structureElement, namingConvention, StructureChoice.APPROVE);
     }
 
     /**
@@ -753,8 +753,8 @@ public class ValidateUtil {
      *
      * @param structureElement structure element
      */
-    public static void validateStructureElementInputCancel(StructureElement structureElement) {
-        validateStructureElementInput(structureElement, StructureChoice.CANCEL);
+    public static void validateStructureElementInputCancel(StructureElement structureElement, EssNamingConvention namingConvention) {
+        validateStructureElementInput(structureElement, namingConvention, StructureChoice.CANCEL);
     }
 
     /**
@@ -762,8 +762,8 @@ public class ValidateUtil {
      *
      * @param structureElement structure element
      */
-    public static void validateStructureElementInputReject(StructureElement structureElement) {
-        validateStructureElementInput(structureElement, StructureChoice.REJECT);
+    public static void validateStructureElementInputReject(StructureElement structureElement, EssNamingConvention namingConvention) {
+        validateStructureElementInput(structureElement, namingConvention, StructureChoice.REJECT);
     }
 
     /**
@@ -772,7 +772,7 @@ public class ValidateUtil {
      * @param structureElement structure element
      * @param structureChoice structure choice
      */
-    private static void validateStructureElementInput(StructureElement structureElement, StructureChoice structureChoice) {
+    private static void validateStructureElementInput(StructureElement structureElement, EssNamingConvention namingConvention, StructureChoice structureChoice) {
         // check structure element input
         //     parent uuid            - also validate data, parent uuid available if type is system, subsystem, device group, device type
         //     name                   - required
@@ -805,11 +805,13 @@ public class ValidateUtil {
         }
 
         validateInputName(structureElement.getName());
-        if (Type.DEVICEGROUP.equals(structureElement.getType())) {
-            validateCondition(StringUtils.isEmpty(structureElement.getMnemonic()), HttpStatus.BAD_REQUEST, "mnemonic " + ValidateUtil.IS_NOT_CORRECT, structureElement.getMnemonic());
-        } else if (!Type.SYSTEMGROUP.equals(structureElement.getType())) {
-            validateInputMnemonic(structureElement.getMnemonic());
-        }
+
+        // validate mnemonic
+        //     validate mnemonic input (value itself, not in relation to other values)
+        //     validateMnemonic takes isMnemonicRequired into account
+        MnemonicValidation mnemonicValidation = namingConvention.validateMnemonic(structureElement.getType(), structureElement.getMnemonic());
+        validateCondition(MnemonicValidation.VALID.equals(mnemonicValidation), HttpStatus.BAD_REQUEST, "mnemonic " + ValidateUtil.IS_NOT_VALID, structureElement.toString());
+
         validateInputDescription(structureElement.getDescription());
         validateInputComment(structureElement.getComment());
     }
diff --git a/src/test/java/org/openepics/names/docker/StructuresDeviceGroupIT.java b/src/test/java/org/openepics/names/docker/StructuresDeviceGroupIT.java
index 7055ffc571139ee5377aff5b5b2e59c95d63a742..183a337a15547588afba84322cf72a302d83b7f4 100644
--- a/src/test/java/org/openepics/names/docker/StructuresDeviceGroupIT.java
+++ b/src/test/java/org/openepics/names/docker/StructuresDeviceGroupIT.java
@@ -204,6 +204,180 @@ public class StructuresDeviceGroupIT {
         }
     }
 
+    @Test
+    public void checkCreateMnemonic() {
+        // purpose
+        //     test conditions for create device group
+        //         not create itself
+        //
+        // what - combination of
+        //     read        validate create
+        //
+        // note
+        //     mnemonic
+        try {
+            ObjectMapper mapper = new ObjectMapper();
+            StructureElement structureElement = new StructureElement();
+            String[] response = null;
+
+            structureElement.setType(Type.DEVICEGROUP);
+            structureElement.setParent(disciplineUuid);
+            structureElement.setName("name");
+            structureElement.setDescription("description");
+            structureElement.setComment("comment");
+
+            // mnemonic rules
+
+            structureElement.setMnemonic(null);
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("C");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Cc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Ccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Cccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Ccccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Cccccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Ccccccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Cccccccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Ccccccccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            // mnemonic rules (2)
+
+            structureElement.setMnemonic(" ");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Grp ");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Grp");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("000");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Grp0");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic(":");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Grp:");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Grp:   ");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("1");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("12");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("123");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("1234");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("12345");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("123456");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("1234567");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("12345678");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("123456789");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+	    } catch (IOException e) {
+	        fail();
+	    } catch (InterruptedException e) {
+	        fail();
+	    } catch (Exception e) {
+	        fail();
+	    }
+	}
+
     @Test
     public void createApprove() {
         // purpose
diff --git a/src/test/java/org/openepics/names/docker/StructuresDeviceTypeIT.java b/src/test/java/org/openepics/names/docker/StructuresDeviceTypeIT.java
index 3f6891d27823256a765203d193bf3d84662e45ee..5935255907359c819f098cc17949bc719adafbb8 100644
--- a/src/test/java/org/openepics/names/docker/StructuresDeviceTypeIT.java
+++ b/src/test/java/org/openepics/names/docker/StructuresDeviceTypeIT.java
@@ -215,6 +215,180 @@ public class StructuresDeviceTypeIT {
         }
     }
 
+    @Test
+    public void checkCreateMnemonic() {
+        // purpose
+        //     test conditions for create device type
+        //         not create itself
+        //
+        // what - combination of
+        //     read        validate create
+        //
+        // note
+        //     mnemonic
+        try {
+            ObjectMapper mapper = new ObjectMapper();
+            StructureElement structureElement = new StructureElement();
+            String[] response = null;
+
+            structureElement.setType(Type.DEVICETYPE);
+            structureElement.setParent(deviceGroupUuid);
+            structureElement.setName("name");
+            structureElement.setDescription("description");
+            structureElement.setComment("comment");
+
+            // mnemonic rules
+
+            structureElement.setMnemonic(null);
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("C");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Cc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Ccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Cccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Ccccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Cccccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Ccccccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Cccccccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Ccccccccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            // mnemonic rules (2)
+
+            structureElement.setMnemonic(" ");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Dev ");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Dev");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("000");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Dev0");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic(":");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Dev:");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Dev:   ");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("1");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("12");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("123");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("1234");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("12345");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("123456");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("1234567");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("12345678");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("123456789");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+	    } catch (IOException e) {
+	        fail();
+	    } catch (InterruptedException e) {
+	        fail();
+	    } catch (Exception e) {
+	        fail();
+	    }
+	}
+
     @Test
     public void createApprove() {
         // purpose
diff --git a/src/test/java/org/openepics/names/docker/StructuresDisciplineIT.java b/src/test/java/org/openepics/names/docker/StructuresDisciplineIT.java
index 2d5c05d9ca3d7b4d275ba5f014f601300c2b79d5..e33d1c1e3a6478c61a2825515898438230cfce2b 100644
--- a/src/test/java/org/openepics/names/docker/StructuresDisciplineIT.java
+++ b/src/test/java/org/openepics/names/docker/StructuresDisciplineIT.java
@@ -170,6 +170,179 @@ public class StructuresDisciplineIT {
         }
     }
 
+    @Test
+    public void checkCreateMnemonic() {
+        // purpose
+        //     test conditions for create discipline
+        //         not create itself
+        //
+        // what - combination of
+        //     read        validate create
+        //
+        // note
+        //     mnemonic
+        try {
+            ObjectMapper mapper = new ObjectMapper();
+            StructureElement structureElement = new StructureElement();
+            String[] response = null;
+
+            structureElement.setType(Type.DISCIPLINE);
+            structureElement.setName("name");
+            structureElement.setDescription("description");
+            structureElement.setComment("comment");
+
+            // mnemonic rules
+
+            structureElement.setMnemonic(null);
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("C");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Cc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Ccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Cccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Ccccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Cccccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Ccccccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Cccccccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Ccccccccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            // mnemonic rules (2)
+
+            structureElement.setMnemonic(" ");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Dis ");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Dis");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("000");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Dis0");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic(":");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Dis:");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Dis:   ");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("1");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("12");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("123");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("1234");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("12345");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("123456");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("1234567");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("12345678");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("123456789");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+	    } catch (IOException e) {
+	        fail();
+	    } catch (InterruptedException e) {
+	        fail();
+	    } catch (Exception e) {
+	        fail();
+	    }
+	}
+
     @Test
     public void createApprove() {
         // purpose
diff --git a/src/test/java/org/openepics/names/docker/StructuresSubsystemIT.java b/src/test/java/org/openepics/names/docker/StructuresSubsystemIT.java
index a82133f23b00bc8631718797e265dd10f9b6a149..fdb0a831e329acb9ba23574d00eb8894f453280a 100644
--- a/src/test/java/org/openepics/names/docker/StructuresSubsystemIT.java
+++ b/src/test/java/org/openepics/names/docker/StructuresSubsystemIT.java
@@ -231,6 +231,180 @@ public class StructuresSubsystemIT {
         }
     }
 
+    @Test
+    public void checkCreateMnemonic() {
+        // purpose
+        //     test conditions for create subsystem
+        //         not create itself
+        //
+        // what - combination of
+        //     read        validate create
+        //
+        // note
+        //     mnemonic
+        try {
+            ObjectMapper mapper = new ObjectMapper();
+            StructureElement structureElement = new StructureElement();
+            String[] response = null;
+
+            structureElement.setType(Type.SUBSYSTEM);
+            structureElement.setParent(systemUuid);
+            structureElement.setName("name");
+            structureElement.setDescription("description");
+            structureElement.setComment("comment");
+
+            // mnemonic rules
+
+            structureElement.setMnemonic(null);
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("C");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Cc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Ccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Cccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Ccccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Cccccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Ccccccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Cccccccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Ccccccccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            // mnemonic rules (2)
+
+            structureElement.setMnemonic(" ");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Sub ");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Sub");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("000");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Sub0");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic(":");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Sub:");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Sub:   ");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("1");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("12");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("123");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("1234");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("12345");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("123456");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("1234567");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("12345678");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("123456789");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+	    } catch (IOException e) {
+	        fail();
+	    } catch (InterruptedException e) {
+	        fail();
+	    } catch (Exception e) {
+	        fail();
+	    }
+	}
+
     @Test
     public void createApprove() {
         // purpose
diff --git a/src/test/java/org/openepics/names/docker/StructuresSystemGroupIT.java b/src/test/java/org/openepics/names/docker/StructuresSystemGroupIT.java
index f836428a2e6232d85768515b47e49d0cd76b55da..8ba7ad9ef167f7a62760c04b9b0ff09a922c7f42 100644
--- a/src/test/java/org/openepics/names/docker/StructuresSystemGroupIT.java
+++ b/src/test/java/org/openepics/names/docker/StructuresSystemGroupIT.java
@@ -186,6 +186,189 @@ public class StructuresSystemGroupIT {
         }
     }
 
+    @Test
+    public void checkCreateMnemonic() {
+        // purpose
+        //     test conditions for create system group
+        //         not create itself
+        //
+        // what - combination of
+        //     read        validate create
+        //
+        // note
+        //     mnemonic
+        try {
+            ObjectMapper mapper = new ObjectMapper();
+            StructureElement structureElement = new StructureElement();
+            String[] response = null;
+
+            structureElement.setType(Type.SYSTEMGROUP);
+            structureElement.setName("name");
+            structureElement.setDescription("description");
+            structureElement.setComment("comment");
+
+            // mnemonic rules
+
+            structureElement.setMnemonic(null);
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("C");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Cc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Ccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Cccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Ccccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Cccccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Ccccccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Cccccccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Ccccccccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            // mnemonic rules (2)
+
+            structureElement.setMnemonic(" ");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Sys ");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Sys");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("000");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Sys0");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic(":");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Sys:");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Sys:   ");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("1");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("12");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("123");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("1234");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("12345");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("123456");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("1234567");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("12345678");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("123456789");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Ac1");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Acc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+	    } catch (IOException e) {
+	        fail();
+	    } catch (InterruptedException e) {
+	        fail();
+	    } catch (Exception e) {
+	        fail();
+	    }
+	}
+
     @Test
     public void createApprove() {
         // purpose
diff --git a/src/test/java/org/openepics/names/docker/StructuresSystemIT.java b/src/test/java/org/openepics/names/docker/StructuresSystemIT.java
index 2c16d0f09ef5d0a3d1a3ac5d37bf2589b21d8054..a2a5bfcf16f4b52fb8b43ba31ea1cb60ecc9949e 100644
--- a/src/test/java/org/openepics/names/docker/StructuresSystemIT.java
+++ b/src/test/java/org/openepics/names/docker/StructuresSystemIT.java
@@ -217,6 +217,180 @@ public class StructuresSystemIT {
         }
     }
 
+    @Test
+    public void checkCreateMnemonic() {
+        // purpose
+        //     test conditions for create system
+        //         not create itself
+        //
+        // what - combination of
+        //     read        validate create
+        //
+        // note
+        //     mnemonic
+        try {
+            ObjectMapper mapper = new ObjectMapper();
+            StructureElement structureElement = new StructureElement();
+            String[] response = null;
+
+            structureElement.setType(Type.SYSTEM);
+            structureElement.setParent(systemGroupUuid);
+            structureElement.setName("name");
+            structureElement.setDescription("description");
+            structureElement.setComment("comment");
+
+            // mnemonic rules
+
+            structureElement.setMnemonic(null);
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("C");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Cc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Ccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Cccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Ccccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Cccccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Ccccccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Cccccccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Ccccccccc");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            // mnemonic rules (2)
+
+            structureElement.setMnemonic(" ");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Sys ");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Sys");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("000");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("Sys0");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic(":");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Sys:");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("Sys:   ");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+
+            structureElement.setMnemonic("1");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("12");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("123");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("1234");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("12345");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("123456");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("1234567");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("12345678");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.TRUE);
+
+            structureElement.setMnemonic("123456789");
+            response = ITUtil.runShellCommand(ITUtil.curlGetPathJson(AuthorizationChoice.NONE, EndpointChoice.STRUCTURES, "/validatecreate", "[" + mapper.writeValueAsString(structureElement) + "]"));
+            ITUtil.assertResponseLength2Code(response, HttpURLConnection.HTTP_OK);
+            ITUtil.assertEqualsResponseBoolean(mapper.readValue(response[1], ResponseBooleanList.class), Boolean.FALSE);
+	    } catch (IOException e) {
+	        fail();
+	    } catch (InterruptedException e) {
+	        fail();
+	    } catch (Exception e) {
+	        fail();
+	    }
+	}
+
     @Test
     public void createApprove() {
         // purpose
diff --git a/src/test/java/org/openepics/names/util/EssNamingConventionTest.java b/src/test/java/org/openepics/names/util/EssNamingConventionTest.java
index 384d0c740fef3fd221c6b151590b7fb09855b80b..6ae55281c895a4785879caeed7a9061e97109560 100644
--- a/src/test/java/org/openepics/names/util/EssNamingConventionTest.java
+++ b/src/test/java/org/openepics/names/util/EssNamingConventionTest.java
@@ -24,6 +24,7 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
+import org.openepics.names.rest.beans.Type;
 
 /**
  * Unit tests for EssNamingConvention class.
@@ -75,6 +76,10 @@ public class EssNamingConventionTest {
     private static final String DIS = "Dis";
     private static final String DEV = "Dev";
     private static final String IDX = "Idx";
+    private static final String GRP = "Grp";
+
+    private static final String SYS_COLON     = "Sys:";
+    private static final String SYS_COLON_S3  = "Sys:   ";
 
     private static final String ECAT10 = "ECAT10";
     private static final String IOC    = "IOC";
@@ -89,6 +94,8 @@ public class EssNamingConventionTest {
     private static final String NUM_12345     = "12345";
     private static final String NUM_123456    = "123456";
     private static final String NUM_1234567   = "1234567";
+    private static final String NUM_12345678  = "12345678";
+    private static final String NUM_123456789 = "123456789";
 
     private static final String ALPHABETIC_NOT_OK       = "alphabetic value not allowed";
     private static final String BLANKS_NOT_OK           = "value with blanks not allowed";
@@ -118,6 +125,202 @@ public class EssNamingConventionTest {
         namingConvention = null;
     }
 
+    // ----------------------------------------------------------------------------------------------------
+    // name by itself
+    //     equivalenceClassRepresentative
+    // ----------------------------------------------------------------------------------------------------
+
+    /**
+     * Test of equivalence class representative method.
+     */
+    @Test
+    public void equivalenceClassRepresentative() {
+        assertEquals("RFQ-10:EMR-TT-1",  namingConvention.equivalenceClassRepresentative("RFQ-010:EMR-TT-001"));
+        assertEquals("RFQ-10:EMR-TT-10", namingConvention.equivalenceClassRepresentative("RFQ-010:EMR-TT-010"));
+        assertEquals("RFQ-10:EMR-TT-11", namingConvention.equivalenceClassRepresentative("RFQ-010:EMR-TT-011"));
+        assertEquals("RFQ-10:EMR-TT-12", namingConvention.equivalenceClassRepresentative("RFQ-010:EMR-TT-012"));
+        assertEquals("RFQ-10:EMR-TT-13", namingConvention.equivalenceClassRepresentative("RFQ-010:EMR-TT-013"));
+        assertEquals("RFQ-10:EMR-TT-14", namingConvention.equivalenceClassRepresentative("RFQ-010:EMR-TT-014"));
+        assertEquals("RFQ-10:EMR-TT-15", namingConvention.equivalenceClassRepresentative("RFQ-010:EMR-TT-015"));
+        assertEquals("RFQ-10:EMR-TT-16", namingConvention.equivalenceClassRepresentative("RFQ-010:EMR-TT-016"));
+        assertEquals("RFQ-10:EMR-TT-17", namingConvention.equivalenceClassRepresentative("RFQ-010:EMR-TT-017"));
+        assertEquals("RFQ-10:EMR-TT-18", namingConvention.equivalenceClassRepresentative("RFQ-010:EMR-TT-018"));
+        assertEquals("RFQ-10:EMR-TT-19", namingConvention.equivalenceClassRepresentative("RFQ-010:EMR-TT-019"));
+
+        assertEquals(
+                "PB1-FPM1:CTR1-ECAT-100",
+                namingConvention.equivalenceClassRepresentative("PBI-FPM01:Ctrl-ECAT-100"));
+        assertEquals(
+                "PB1-FPM1:CTR1-ECATC-101",
+                namingConvention.equivalenceClassRepresentative("PBI-FPM01:Ctrl-ECATC-101"));
+        assertEquals(
+                "PB1-FPM1:CTR1-ECATE-101",
+                namingConvention.equivalenceClassRepresentative("PBI-FPM01:Ctrl-ECATE-101"));
+        assertEquals(
+                "PB1-FPM1:CTR1-ECAT10-101",
+                namingConvention.equivalenceClassRepresentative("PBI-FPM01:Ctrl-ECATIO-101"));
+        assertEquals(
+                "PB1-FPM1:CTR1-ECAT10-102",
+                namingConvention.equivalenceClassRepresentative("PBI-FPM01:Ctrl-ECATIO-102"));
+        assertEquals(
+                "PB1-FPM1:CTR1-ECAT10-103",
+                namingConvention.equivalenceClassRepresentative("PBI-FPM01:Ctrl-ECATIO-103"));
+        assertEquals(
+                "PB1-FPM1:CTR1-ECAT10-104",
+                namingConvention.equivalenceClassRepresentative("PBI-FPM01:Ctrl-ECATIO-104"));
+        assertEquals(
+                "PB1-FPM1:CTR1-EVR-101",
+                namingConvention.equivalenceClassRepresentative("PBI-FPM01:Ctrl-EVR-101"));
+        assertEquals(
+                "PB1-FPM1:CTR1-EVR-201",
+                namingConvention.equivalenceClassRepresentative("PBI-FPM01:Ctrl-EVR-201"));
+        assertEquals(
+                "PB1-FPM1:CTR1-1PC-100",
+                namingConvention.equivalenceClassRepresentative("PBI-FPM01:Ctrl-IPC-100"));
+        assertEquals(
+                "PB1-FPM1:CTR1-1PC-200",
+                namingConvention.equivalenceClassRepresentative("PBI-FPM01:Ctrl-IPC-200"));
+    }
+
+    /**
+     * Test of equivalence class representative method for similarity to <tt>1</tt>.
+     */
+    @Test
+    public void equivalenceClassRepresentativeSimilarTo1() {
+        assertEquals(
+                namingConvention.equivalenceClassRepresentative(NUM_1),
+                namingConvention.equivalenceClassRepresentative(NUM_1));
+        assertEquals(
+                namingConvention.equivalenceClassRepresentative(NUM_1),
+                namingConvention.equivalenceClassRepresentative("I"));
+        assertEquals(
+                namingConvention.equivalenceClassRepresentative(NUM_1),
+                namingConvention.equivalenceClassRepresentative("l"));
+        assertEquals(
+                namingConvention.equivalenceClassRepresentative(NUM_1),
+                namingConvention.equivalenceClassRepresentative("L"));
+        assertEquals(
+                namingConvention.equivalenceClassRepresentative(NUM_1),
+                namingConvention.equivalenceClassRepresentative("i"));
+        assertFalse(
+                namingConvention.equivalenceClassRepresentative(NUM_1).equals(
+                        namingConvention.equivalenceClassRepresentative("b")));
+    }
+
+    /**
+     * Test of equivalence class representative method for similarity to <tt>0</tt>.
+     */
+    @Test
+    public void equivalenceClassRepresentativeSimilarTo0() {
+        assertEquals(
+                namingConvention.equivalenceClassRepresentative(NUM_0),
+                namingConvention.equivalenceClassRepresentative("o"));
+        assertEquals(
+                namingConvention.equivalenceClassRepresentative(NUM_0),
+                namingConvention.equivalenceClassRepresentative("O"));
+        assertEquals(
+                namingConvention.equivalenceClassRepresentative(NUM_0),
+                namingConvention.equivalenceClassRepresentative(NUM_0));
+        assertFalse(
+                namingConvention.equivalenceClassRepresentative(NUM_0).equals(
+                        namingConvention.equivalenceClassRepresentative("b")));
+    }
+
+    /**
+     * Test of equivalence class representative method for similarity to <tt>V</tt>.
+     */
+    @Test
+    public void equivalenceClassRepresentativeSimilarToV() {
+        assertEquals(
+                namingConvention.equivalenceClassRepresentative("V"),
+                namingConvention.equivalenceClassRepresentative("v"));
+        assertEquals(
+                namingConvention.equivalenceClassRepresentative("V"),
+                namingConvention.equivalenceClassRepresentative("V"));
+        assertFalse(
+                namingConvention.equivalenceClassRepresentative("V1").equals(
+                        namingConvention.equivalenceClassRepresentative("w1")));
+        assertFalse(
+                namingConvention.equivalenceClassRepresentative("V1").equals(
+                        namingConvention.equivalenceClassRepresentative("W1")));
+        assertFalse(
+                namingConvention.equivalenceClassRepresentative("V").equals(
+                        namingConvention.equivalenceClassRepresentative("w")));
+        assertFalse(
+                namingConvention.equivalenceClassRepresentative("V").equals(
+                        namingConvention.equivalenceClassRepresentative("W")));
+        assertFalse(
+                namingConvention.equivalenceClassRepresentative("V").equals(
+                        namingConvention.equivalenceClassRepresentative("b")));
+    }
+
+    /**
+     * Test of equivalence class representative method for lower and upper case characters.
+     */
+    @Test
+    public void equivalenceClassRepresentativeLowerAndUpperCaseCharacters() {
+        assertEquals(
+                namingConvention.equivalenceClassRepresentative("tEsTS"),
+                namingConvention.equivalenceClassRepresentative("TeSts"));
+    }
+
+    /**
+     * Test of equivalence class representative method for zero prefixed number.
+     */
+    @Test
+    public void equivalenceClassRepresentativeZeroPrefixedNumber() {
+        assertEquals(
+                namingConvention.equivalenceClassRepresentative("01"),
+                namingConvention.equivalenceClassRepresentative("001"));
+        assertEquals(
+                namingConvention.equivalenceClassRepresentative("zero01"),
+                namingConvention.equivalenceClassRepresentative("zero1"));
+        assertEquals(
+                namingConvention.equivalenceClassRepresentative("ze01ro"),
+                namingConvention.equivalenceClassRepresentative("ze1ro"));
+    }
+
+    /**
+     * Test of equivalence class representative method for zero after alpha character.
+     */
+    @Test
+    public void equivalenceClassRepresentativeZeroAfterAlphaCharacter() {
+        assertEquals(
+                namingConvention.equivalenceClassRepresentative("Sub0001"),
+                namingConvention.equivalenceClassRepresentative("Sub1"));
+        assertEquals(
+                namingConvention.equivalenceClassRepresentative("01Sub001"),
+                namingConvention.equivalenceClassRepresentative("01Sub1"));
+    }
+
+    /**
+     * Test of equivalence class representative method for chained calls to get equivalence class.
+     */
+    @Test
+    public void equivalenceClassRepresentativeTwiceEquivalence() {
+        // note that of 2 chained calls to equivalenceClassRepresentative, 2nd call may modify
+        // <==> 2nd output not same as 1st output
+        assertEquals(
+                "CRS-T1CP:CRY0-XZ-XXXXX1",
+                namingConvention.equivalenceClassRepresentative("CrS-TICP:Cryo-XZ-XXXXX1"));
+        assertEquals(
+                "CRS-T1CP:CRY-XZ-XXXXX1",
+                namingConvention.equivalenceClassRepresentative("CRS-T1CP:CRY0-XZ-XXXXX1"));
+        assertEquals("CRY0",   namingConvention.equivalenceClassRepresentative("Cryo"));
+        assertEquals("CRY",    namingConvention.equivalenceClassRepresentative("CRY0"));
+    }
+
+    /**
+     * Test of equivalence class representative method for device type.
+     */
+    @Test
+    public void equivalenceClassRepresentativeDeviceType() {
+        // note handling of trailing zeroes
+        assertEquals(ECAT10,   namingConvention.equivalenceClassRepresentative("ECATIO"));
+        assertEquals("ECAT1",  namingConvention.equivalenceClassRepresentative("ECATI0"));
+        assertEquals(ECAT10,   namingConvention.equivalenceClassRepresentative(ECAT10));
+    }
+
     // ----------------------------------------------------------------------------------------------------
     // name by itself
     //     isInstanceIndexValid
@@ -768,221 +971,237 @@ public class EssNamingConventionTest {
         assertFalse(namingConvention.isInstanceIndexValid(systemStructure2 + ":" + deviceStructure28 + "-" + _001ABCD, true));
     }
 
-    // ----------------------------------------------------------------------------------------------------
-    // name by itself
-    //     equivalenceClassRepresentative
-    // ----------------------------------------------------------------------------------------------------
-
     /**
-     * Test of equivalence class representative method.
+     * Test validity of mnemonic path.
      */
     @Test
-    public void equivalenceClassRepresentative() {
-        assertEquals("RFQ-10:EMR-TT-1",  namingConvention.equivalenceClassRepresentative("RFQ-010:EMR-TT-001"));
-        assertEquals("RFQ-10:EMR-TT-10", namingConvention.equivalenceClassRepresentative("RFQ-010:EMR-TT-010"));
-        assertEquals("RFQ-10:EMR-TT-11", namingConvention.equivalenceClassRepresentative("RFQ-010:EMR-TT-011"));
-        assertEquals("RFQ-10:EMR-TT-12", namingConvention.equivalenceClassRepresentative("RFQ-010:EMR-TT-012"));
-        assertEquals("RFQ-10:EMR-TT-13", namingConvention.equivalenceClassRepresentative("RFQ-010:EMR-TT-013"));
-        assertEquals("RFQ-10:EMR-TT-14", namingConvention.equivalenceClassRepresentative("RFQ-010:EMR-TT-014"));
-        assertEquals("RFQ-10:EMR-TT-15", namingConvention.equivalenceClassRepresentative("RFQ-010:EMR-TT-015"));
-        assertEquals("RFQ-10:EMR-TT-16", namingConvention.equivalenceClassRepresentative("RFQ-010:EMR-TT-016"));
-        assertEquals("RFQ-10:EMR-TT-17", namingConvention.equivalenceClassRepresentative("RFQ-010:EMR-TT-017"));
-        assertEquals("RFQ-10:EMR-TT-18", namingConvention.equivalenceClassRepresentative("RFQ-010:EMR-TT-018"));
-        assertEquals("RFQ-10:EMR-TT-19", namingConvention.equivalenceClassRepresentative("RFQ-010:EMR-TT-019"));
+    public void isMnemonicPathValid() {
+        assertFalse(namingConvention.isMnemonicPathValid(NULL));
+        assertFalse(namingConvention.isMnemonicPathValid(EMPTY));
+        assertFalse(namingConvention.isMnemonicPathValid(SPACE));
 
-        assertEquals(
-                "PB1-FPM1:CTR1-ECAT-100",
-                namingConvention.equivalenceClassRepresentative("PBI-FPM01:Ctrl-ECAT-100"));
-        assertEquals(
-                "PB1-FPM1:CTR1-ECATC-101",
-                namingConvention.equivalenceClassRepresentative("PBI-FPM01:Ctrl-ECATC-101"));
-        assertEquals(
-                "PB1-FPM1:CTR1-ECATE-101",
-                namingConvention.equivalenceClassRepresentative("PBI-FPM01:Ctrl-ECATE-101"));
-        assertEquals(
-                "PB1-FPM1:CTR1-ECAT10-101",
-                namingConvention.equivalenceClassRepresentative("PBI-FPM01:Ctrl-ECATIO-101"));
-        assertEquals(
-                "PB1-FPM1:CTR1-ECAT10-102",
-                namingConvention.equivalenceClassRepresentative("PBI-FPM01:Ctrl-ECATIO-102"));
-        assertEquals(
-                "PB1-FPM1:CTR1-ECAT10-103",
-                namingConvention.equivalenceClassRepresentative("PBI-FPM01:Ctrl-ECATIO-103"));
-        assertEquals(
-                "PB1-FPM1:CTR1-ECAT10-104",
-                namingConvention.equivalenceClassRepresentative("PBI-FPM01:Ctrl-ECATIO-104"));
-        assertEquals(
-                "PB1-FPM1:CTR1-EVR-101",
-                namingConvention.equivalenceClassRepresentative("PBI-FPM01:Ctrl-EVR-101"));
-        assertEquals(
-                "PB1-FPM1:CTR1-EVR-201",
-                namingConvention.equivalenceClassRepresentative("PBI-FPM01:Ctrl-EVR-201"));
-        assertEquals(
-                "PB1-FPM1:CTR1-1PC-100",
-                namingConvention.equivalenceClassRepresentative("PBI-FPM01:Ctrl-IPC-100"));
-        assertEquals(
-                "PB1-FPM1:CTR1-1PC-200",
-                namingConvention.equivalenceClassRepresentative("PBI-FPM01:Ctrl-IPC-200"));
-    }
+        assertTrue (namingConvention.isMnemonicPathValid("A"));
+        assertTrue (namingConvention.isMnemonicPathValid("A-B"));
+        assertTrue (namingConvention.isMnemonicPathValid("A-B-C"));
+        assertFalse(namingConvention.isMnemonicPathValid("A-B-C-D"));
 
-    /**
-     * Test of equivalence class representative method for similarity to <tt>1</tt>.
-     */
-    @Test
-    public void equivalenceClassRepresentativeSimilarTo1() {
-        assertEquals(
-                namingConvention.equivalenceClassRepresentative(NUM_1),
-                namingConvention.equivalenceClassRepresentative(NUM_1));
-        assertEquals(
-                namingConvention.equivalenceClassRepresentative(NUM_1),
-                namingConvention.equivalenceClassRepresentative("I"));
-        assertEquals(
-                namingConvention.equivalenceClassRepresentative(NUM_1),
-                namingConvention.equivalenceClassRepresentative("l"));
-        assertEquals(
-                namingConvention.equivalenceClassRepresentative(NUM_1),
-                namingConvention.equivalenceClassRepresentative("L"));
-        assertEquals(
-                namingConvention.equivalenceClassRepresentative(NUM_1),
-                namingConvention.equivalenceClassRepresentative("i"));
-        assertFalse(
-                namingConvention.equivalenceClassRepresentative(NUM_1).equals(
-                        namingConvention.equivalenceClassRepresentative("b")));
+        assertFalse(namingConvention.isMnemonicPathValid("A-A"));
+        assertFalse(namingConvention.isMnemonicPathValid("A-A-A"));
+        assertFalse(namingConvention.isMnemonicPathValid("A-A-B"));
+        assertFalse(namingConvention.isMnemonicPathValid("A-B-A"));
+        assertFalse(namingConvention.isMnemonicPathValid("B-A-A"));
     }
 
     /**
-     * Test of equivalence class representative method for similarity to <tt>0</tt>.
+     * Test if mnemonic is required.
      */
     @Test
-    public void equivalenceClassRepresentativeSimilarTo0() {
-        assertEquals(
-                namingConvention.equivalenceClassRepresentative(NUM_0),
-                namingConvention.equivalenceClassRepresentative("o"));
-        assertEquals(
-                namingConvention.equivalenceClassRepresentative(NUM_0),
-                namingConvention.equivalenceClassRepresentative("O"));
-        assertEquals(
-                namingConvention.equivalenceClassRepresentative(NUM_0),
-                namingConvention.equivalenceClassRepresentative(NUM_0));
-        assertFalse(
-                namingConvention.equivalenceClassRepresentative(NUM_0).equals(
-                        namingConvention.equivalenceClassRepresentative("b")));
-    }
+    public void isMnemonicRequired() {
+        assertFalse(namingConvention.isMnemonicRequired(null));
 
-    /**
-     * Test of equivalence class representative method for similarity to <tt>V</tt>.
-     */
-    @Test
-    public void equivalenceClassRepresentativeSimilarToV() {
-        assertEquals(
-                namingConvention.equivalenceClassRepresentative("V"),
-                namingConvention.equivalenceClassRepresentative("v"));
-        assertEquals(
-                namingConvention.equivalenceClassRepresentative("V"),
-                namingConvention.equivalenceClassRepresentative("V"));
-        assertFalse(
-                namingConvention.equivalenceClassRepresentative("V1").equals(
-                        namingConvention.equivalenceClassRepresentative("w1")));
-        assertFalse(
-                namingConvention.equivalenceClassRepresentative("V1").equals(
-                        namingConvention.equivalenceClassRepresentative("W1")));
-        assertFalse(
-                namingConvention.equivalenceClassRepresentative("V").equals(
-                        namingConvention.equivalenceClassRepresentative("w")));
-        assertFalse(
-                namingConvention.equivalenceClassRepresentative("V").equals(
-                        namingConvention.equivalenceClassRepresentative("W")));
-        assertFalse(
-                namingConvention.equivalenceClassRepresentative("V").equals(
-                        namingConvention.equivalenceClassRepresentative("b")));
+        assertFalse(namingConvention.isMnemonicRequired(Type.SYSTEMGROUP));
+        assertTrue (namingConvention.isMnemonicRequired(Type.SYSTEM));
+        assertTrue (namingConvention.isMnemonicRequired(Type.SUBSYSTEM));
+
+        assertTrue (namingConvention.isMnemonicRequired(Type.DISCIPLINE));
+        assertFalse(namingConvention.isMnemonicRequired(Type.DEVICEGROUP));
+        assertTrue (namingConvention.isMnemonicRequired(Type.DEVICETYPE));
     }
 
+    // ----------------------------------------------------------------------------------------------------
+    // name by itself
+    //     validateMnemonic
+    //         system structure
+    //         device structure
+    // ----------------------------------------------------------------------------------------------------
+
+    // empty
+    // blank
+    // alphabetic
+    // numeric
+    // alphanumeric
+    // non-alphanumeric
+    // length
+    // mix
+
     /**
-     * Test of equivalence class representative method for lower and upper case characters.
+     * Test validity of mnemonic for system group.
      */
     @Test
-    public void equivalenceClassRepresentativeLowerAndUpperCaseCharacters() {
-        assertEquals(
-                namingConvention.equivalenceClassRepresentative("tEsTS"),
-                namingConvention.equivalenceClassRepresentative("TeSts"));
+    public void isSystemGroupValid(){
+        assertEquals(MnemonicValidation.VALID,                testSystemGroup(NULL));
+        assertEquals(MnemonicValidation.VALID,                testSystemGroup(EMPTY));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testSystemGroup(SPACE));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testSystemGroup("Sys "));
+        assertEquals(MnemonicValidation.VALID,                testSystemGroup(SYS));
+        assertEquals(MnemonicValidation.VALID,                testSystemGroup(NUM_123));
+        assertEquals(MnemonicValidation.VALID,                testSystemGroup("000"));
+        assertEquals(MnemonicValidation.VALID,                testSystemGroup("Sys0"));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testSystemGroup(":"));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testSystemGroup(SYS_COLON));
+        assertEquals(MnemonicValidation.TOO_LONG,             testSystemGroup(SYS_COLON_S3));
+        assertEquals(MnemonicValidation.VALID,                testSystemGroup(NUM_1));
+        assertEquals(MnemonicValidation.VALID,                testSystemGroup(NUM_12));
+        assertEquals(MnemonicValidation.VALID,                testSystemGroup(NUM_123));
+        assertEquals(MnemonicValidation.VALID,                testSystemGroup(NUM_1234));
+        assertEquals(MnemonicValidation.VALID,                testSystemGroup(NUM_12345));
+        assertEquals(MnemonicValidation.VALID,                testSystemGroup(NUM_123456));
+        assertEquals(MnemonicValidation.TOO_LONG,             testSystemGroup(NUM_1234567));
+
+        // other
+        assertEquals(MnemonicValidation.VALID,                testSystemGroup("Ac1"));
+        assertEquals(MnemonicValidation.VALID,                testSystemGroup("Acc"));
     }
 
     /**
-     * Test of equivalence class representative method for zero prefixed number.
+     * Test validity of mnemonic for system.
      */
     @Test
-    public void equivalenceClassRepresentativeZeroPrefixedNumber() {
-        assertEquals(
-                namingConvention.equivalenceClassRepresentative("01"),
-                namingConvention.equivalenceClassRepresentative("001"));
-        assertEquals(
-                namingConvention.equivalenceClassRepresentative("zero01"),
-                namingConvention.equivalenceClassRepresentative("zero1"));
-        assertEquals(
-                namingConvention.equivalenceClassRepresentative("ze01ro"),
-                namingConvention.equivalenceClassRepresentative("ze1ro"));
+    public void isSystemValid() {
+        assertEquals(MnemonicValidation.EMPTY,                testSystem(NULL));
+        assertEquals(MnemonicValidation.EMPTY,                testSystem(EMPTY));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testSystem(SPACE));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testSystem("Sys "));
+        assertEquals(MnemonicValidation.VALID,                testSystem(SYS));
+        assertEquals(MnemonicValidation.VALID,                testSystem(NUM_123));
+        assertEquals(MnemonicValidation.VALID,                testSystem("000"));
+        assertEquals(MnemonicValidation.VALID,                testSystem("Sys0"));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testSystem(":"));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testSystem(SYS_COLON));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testSystem(SYS_COLON_S3));
+        assertEquals(MnemonicValidation.VALID,                testSystem(NUM_1));
+        assertEquals(MnemonicValidation.VALID,                testSystem(NUM_12));
+        assertEquals(MnemonicValidation.VALID,                testSystem(NUM_123));
+        assertEquals(MnemonicValidation.VALID,                testSystem(NUM_1234));
+        assertEquals(MnemonicValidation.VALID,                testSystem(NUM_12345));
+        assertEquals(MnemonicValidation.VALID,                testSystem(NUM_123456));
+        assertEquals(MnemonicValidation.VALID,                testSystem(NUM_1234567));
+        assertEquals(MnemonicValidation.VALID,                testSystem(NUM_12345678));
+        assertEquals(MnemonicValidation.TOO_LONG,             testSystem(NUM_123456789));
     }
 
     /**
-     * Test of equivalence class representative method for zero after alpha character.
+     * Test validity of mnemonic for subsystem.
      */
     @Test
-    public void equivalenceClassRepresentativeZeroAfterAlphaCharacter() {
-        assertEquals(
-                namingConvention.equivalenceClassRepresentative("Sub0001"),
-                namingConvention.equivalenceClassRepresentative("Sub1"));
-        assertEquals(
-                namingConvention.equivalenceClassRepresentative("01Sub001"),
-                namingConvention.equivalenceClassRepresentative("01Sub1"));
+    public void isSubsystemValid() {
+        assertEquals(MnemonicValidation.EMPTY,                testSubsystem(NULL));
+        assertEquals(MnemonicValidation.EMPTY,                testSubsystem(EMPTY));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testSubsystem(SPACE));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testSubsystem("Sub "));
+        assertEquals(MnemonicValidation.VALID,                testSubsystem(SUB));
+        assertEquals(MnemonicValidation.VALID,                testSubsystem(NUM_123));
+        assertEquals(MnemonicValidation.VALID,                testSubsystem("000"));
+        assertEquals(MnemonicValidation.VALID,                testSubsystem("Sub0"));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testSubsystem(":"));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testSubsystem("Sub:"));
+        assertEquals(MnemonicValidation.TOO_LONG,             testSubsystem("Sub:     "));
+        assertEquals(MnemonicValidation.VALID,                testSubsystem(NUM_1));
+        assertEquals(MnemonicValidation.VALID,                testSubsystem(NUM_12));
+        assertEquals(MnemonicValidation.VALID,                testSubsystem(NUM_123));
+        assertEquals(MnemonicValidation.VALID,                testSubsystem(NUM_1234));
+        assertEquals(MnemonicValidation.VALID,                testSubsystem(NUM_12345));
+        assertEquals(MnemonicValidation.VALID,                testSubsystem(NUM_123456));
+        assertEquals(MnemonicValidation.VALID,                testSubsystem(NUM_1234567));
+        assertEquals(MnemonicValidation.VALID,                testSubsystem(NUM_12345678));
+        assertEquals(MnemonicValidation.TOO_LONG,             testSubsystem(NUM_123456789));
     }
 
     /**
-     * Test of equivalence class representative method for chained calls to get equivalence class.
+     * Test validity of mnemonic for discipline.
      */
     @Test
-    public void equivalenceClassRepresentativeTwiceEquivalence() {
-        // note that of 2 chained calls to equivalenceClassRepresentative, 2nd call may modify
-        // <==> 2nd output not same as 1st output
-        assertEquals(
-                "CRS-T1CP:CRY0-XZ-XXXXX1",
-                namingConvention.equivalenceClassRepresentative("CrS-TICP:Cryo-XZ-XXXXX1"));
-        assertEquals(
-                "CRS-T1CP:CRY-XZ-XXXXX1",
-                namingConvention.equivalenceClassRepresentative("CRS-T1CP:CRY0-XZ-XXXXX1"));
-        assertEquals("CRY0",   namingConvention.equivalenceClassRepresentative("Cryo"));
-        assertEquals("CRY",    namingConvention.equivalenceClassRepresentative("CRY0"));
+    public void isDisciplineValid() {
+        assertEquals(MnemonicValidation.EMPTY,                testDiscipline(NULL));
+        assertEquals(MnemonicValidation.EMPTY,                testDiscipline(EMPTY));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testDiscipline(SPACE));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testDiscipline("Dis "));
+        assertEquals(MnemonicValidation.VALID,                testDiscipline(DIS));
+        assertEquals(MnemonicValidation.VALID,                testDiscipline(NUM_123));
+        assertEquals(MnemonicValidation.VALID,                testDiscipline("000"));
+        assertEquals(MnemonicValidation.VALID,                testDiscipline("Dis0"));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testDiscipline(":"));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testDiscipline("Dis:"));
+        assertEquals(MnemonicValidation.TOO_LONG,             testDiscipline("Dis:   "));
+        assertEquals(MnemonicValidation.VALID,                testDiscipline(NUM_1));
+        assertEquals(MnemonicValidation.VALID,                testDiscipline(NUM_12));
+        assertEquals(MnemonicValidation.VALID,                testDiscipline(NUM_123));
+        assertEquals(MnemonicValidation.VALID,                testDiscipline(NUM_1234));
+        assertEquals(MnemonicValidation.VALID,                testDiscipline(NUM_12345));
+        assertEquals(MnemonicValidation.VALID,                testDiscipline(NUM_123456));
+        assertEquals(MnemonicValidation.TOO_LONG,             testDiscipline(NUM_1234567));
     }
 
     /**
-     * Test of equivalence class representative method for device type.
+     * Test validity of mnemonic for device group.
      */
     @Test
-    public void equivalenceClassRepresentativeDeviceType() {
-        // note handling of trailing zeroes
-        assertEquals(ECAT10,   namingConvention.equivalenceClassRepresentative("ECATIO"));
-        assertEquals("ECAT1",  namingConvention.equivalenceClassRepresentative("ECATI0"));
-        assertEquals(ECAT10,   namingConvention.equivalenceClassRepresentative(ECAT10));
+    public void isDeviceGroupValid() {
+        assertEquals(MnemonicValidation.VALID,                testDeviceGroup(NULL));
+        assertEquals(MnemonicValidation.VALID,                testDeviceGroup(EMPTY));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testDeviceGroup(SPACE));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testDeviceGroup("Grp "));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testDeviceGroup(GRP));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testDeviceGroup(NUM_123));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testDeviceGroup("000"));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testDeviceGroup("Grp0"));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testDeviceGroup(":"));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testDeviceGroup("Grp:"));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testDeviceGroup("Grp:   "));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testDeviceGroup(NUM_1));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testDeviceGroup(NUM_12));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testDeviceGroup(NUM_123));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testDeviceGroup(NUM_1234));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testDeviceGroup(NUM_12345));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testDeviceGroup(NUM_123456));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testDeviceGroup("123456789012345"));
     }
 
     /**
-     * Test validity of mnemonic path.
+     * Test validity of mnemonic for device type.
      */
     @Test
-    public void isMnemonicPathValid() {
-        assertFalse(namingConvention.isMnemonicPathValid(NULL));
-        assertFalse(namingConvention.isMnemonicPathValid(EMPTY));
-        assertFalse(namingConvention.isMnemonicPathValid(SPACE));
+    public void isDeviceTypeValid() {
+        assertEquals(MnemonicValidation.EMPTY,                testDeviceType(NULL));
+        assertEquals(MnemonicValidation.EMPTY,                testDeviceType(EMPTY));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testDeviceType(SPACE));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testDeviceType("Dev "));
+        assertEquals(MnemonicValidation.VALID,                testDeviceType(DEV));
+        assertEquals(MnemonicValidation.VALID,                testDeviceType(NUM_123));
+        assertEquals(MnemonicValidation.VALID,                testDeviceType("000"));
+        assertEquals(MnemonicValidation.VALID,                testDeviceType("Dev0"));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testDeviceType(":"));
+        assertEquals(MnemonicValidation.NON_ACCEPTABLE_CHARS, testDeviceType("Dev:"));
+        assertEquals(MnemonicValidation.TOO_LONG,             testDeviceType("Dev:   "));
+        assertEquals(MnemonicValidation.VALID,                testDeviceType(NUM_1));
+        assertEquals(MnemonicValidation.VALID,                testDeviceType(NUM_12));
+        assertEquals(MnemonicValidation.VALID,                testDeviceType(NUM_123));
+        assertEquals(MnemonicValidation.VALID,                testDeviceType(NUM_1234));
+        assertEquals(MnemonicValidation.VALID,                testDeviceType(NUM_12345));
+        assertEquals(MnemonicValidation.VALID,                testDeviceType(NUM_123456));
+        assertEquals(MnemonicValidation.TOO_LONG,             testDeviceType(NUM_1234567));
+    }
 
-        assertTrue (namingConvention.isMnemonicPathValid("A"));
-        assertTrue (namingConvention.isMnemonicPathValid("A-B"));
-        assertTrue (namingConvention.isMnemonicPathValid("A-B-C"));
-        assertFalse(namingConvention.isMnemonicPathValid("A-B-C-D"));
+    // ----------------------------------------------------------------------------------------------------
 
-        assertFalse(namingConvention.isMnemonicPathValid("A-A"));
-        assertFalse(namingConvention.isMnemonicPathValid("A-A-A"));
-        assertFalse(namingConvention.isMnemonicPathValid("A-A-B"));
-        assertFalse(namingConvention.isMnemonicPathValid("A-B-A"));
-        assertFalse(namingConvention.isMnemonicPathValid("B-A-A"));
+    // utility methods
+    private MnemonicValidation testSystemGroup(String mnemonic){
+        return namingConvention.validateMnemonic(Type.SYSTEMGROUP, mnemonic);
+    }
+    private MnemonicValidation testSystem(String mnemonic){
+        return namingConvention.validateMnemonic(Type.SYSTEM, mnemonic);
+    }
+    private MnemonicValidation testSubsystem(String mnemonic){
+        return namingConvention.validateMnemonic(Type.SUBSYSTEM, mnemonic);
+    }
+    private MnemonicValidation testDiscipline(String mnemonic){
+        return namingConvention.validateMnemonic(Type.DISCIPLINE, mnemonic);
+    }
+    private MnemonicValidation testDeviceGroup(String mnemonic){
+        return namingConvention.validateMnemonic(Type.DEVICEGROUP, mnemonic);
+    }
+    private MnemonicValidation testDeviceType(String mnemonic){
+        return namingConvention.validateMnemonic(Type.DEVICETYPE, mnemonic);
     }
 
 }
diff --git a/src/test/java/org/openepics/names/util/ValidateUtilTest.java b/src/test/java/org/openepics/names/util/ValidateUtilTest.java
index cf32a4a08a3b9a4ce208c3f60d28592fa05ef507..98118ac814e4525b121554c77dcca409a42144e4 100644
--- a/src/test/java/org/openepics/names/util/ValidateUtilTest.java
+++ b/src/test/java/org/openepics/names/util/ValidateUtilTest.java
@@ -379,7 +379,7 @@ public class ValidateUtilTest {
      */
     @Test
     public void validateInputUpdateStructureElement() {
-        ValidateUtil.validateStructureElementInputUpdate(null);
+        ValidateUtil.validateStructureElementInputUpdate(null, null);
     }
 
     /**